commit e9c3053d61a5c9b49dc91d5227248ab13e8a3e79 · anil.recoil.org/ocaml-yamlrw

+18

.gitignore

···

       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
       +
       # Editor and OS files

     

       10
       10
       +
       .DS_Store

     

       11
       11
       +
       *.swp

     

       12
       12
       +
       *~

     

       13
       13
       +
       .vscode/

     

       14
       14
       +
       .idea/

     

       15
       15
       +
       

     

       16
       16
       +
       # Opam local switch

     

       17
       17
       +
       _opam/

     

       18
       18
       +
       bytesrw-eio

.ocamlformat

···

       1
       1
       +
       version=0.28.1

+49

.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
       +
       

     

       30
       30
       +
       steps:

     

       31
       31
       +
         - name: opam

     

       32
       32
       +
           command: |

     

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

     

       34
       34
       +
         - name: switch

     

       35
       35
       +
           command: |

     

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

     

       37
       37
       +
         - name: build

     

       38
       38
       +
           command: |

     

       39
       39
       +
              opam exec -- dune build

     

       40
       40
       +
         - name: switch-test

     

       41
       41
       +
           command: |

     

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

     

       43
       43
       +
         - name: test

     

       44
       44
       +
           command: |

     

       45
       45
       +
              opam exec -- dune runtest --verbose

     

       46
       46
       +
         - name: doc

     

       47
       47
       +
           command: |

     

       48
       48
       +
              opam install -y odoc

     

       49
       49
       +
              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.

+94

README.md

···

       1
       1
       +
       # Yamlrw

     

       2
       2
       +
       

     

       3
       3
       +
       A pure OCaml implementation of YAML 1.2 parsing and emission.

     

       4
       4
       +
       

     

       5
       5
       +
       ## Features

     

       6
       6
       +
       

     

       7
       7
       +
       - **Pure OCaml**: No C bindings, works on all OCaml platforms

     

       8
       8
       +
       - **YAML 1.2 Compliant**: Full support for the YAML 1.2 specification

     

       9
       9
       +
       - **High-level API**: JSON-compatible value representation for simple use cases

     

       10
       10
       +
       - **Low-level Streaming**: Event-based parsing for fine-grained control

     

       11
       11
       +
       - **Multiple I/O Backends**:

     

       12
       12
       +
         - `yamlrw`: Core library with bytesrw-based I/O

     

       13
       13
       +
         - `yamlrw-unix`: Unix file and channel operations

     

       14
       14
       +
         - `yamlrw-eio`: Eio-based streaming I/O (OCaml 5.0+)

     

       15
       15
       +
       

     

       16
       16
       +
       ## Installation

     

       17
       17
       +
       

     

       18
       18
       +
       ```bash

     

       19
       19
       +
       opam install yamlrw

     

       20
       20
       +
       # For Eio support:

     

       21
       21
       +
       opam install yamlrw-eio

     

       22
       22
       +
       # For Unix support:

     

       23
       23
       +
       opam install yamlrw-unix

     

       24
       24
       +
       ```

     

       25
       25
       +
       

     

       26
       26
       +
       ## Quick Start

     

       27
       27
       +
       

     

       28
       28
       +
       ### Parsing YAML

     

       29
       29
       +
       

     

       30
       30
       +
       ```ocaml

     

       31
       31
       +
       let value = Yamlrw.of_string "name: Alice\nage: 30" in

     

       32
       32
       +
       match value with

     

       33
       33
       +
       | `O [("name", `String "Alice"); ("age", `Float 30.)] ->

     

       34
       34
       +
           print_endline "Parsed successfully"

     

       35
       35
       +
       | _ ->

     

       36
       36
       +
           print_endline "Unexpected structure"

     

       37
       37
       +
       ```

     

       38
       38
       +
       

     

       39
       39
       +
       ### Emitting YAML

     

       40
       40
       +
       

     

       41
       41
       +
       ```ocaml

     

       42
       42
       +
       let yaml = `O [

     

       43
       43
       +
         ("name", `String "Bob");

     

       44
       44
       +
         ("active", `Bool true);

     

       45
       45
       +
         ("tags", `A [`String "developer"; `String "ocaml"])

     

       46
       46
       +
       ] in

     

       47
       47
       +
       let s = Yamlrw.to_string yaml in

     

       48
       48
       +
       print_endline s

     

       49
       49
       +
       (* Output:

     

       50
       50
       +
          name: Bob

     

       51
       51
       +
          active: true

     

       52
       52
       +
          tags:

     

       53
       53
       +
            - developer

     

       54
       54
       +
            - ocaml

     

       55
       55
       +
       *)

     

       56
       56
       +
       ```

     

       57
       57
       +
       

     

       58
       58
       +
       ### Using the Utility Functions

     

       59
       59
       +
       

     

       60
       60
       +
       ```ocaml

     

       61
       61
       +
       open Yamlrw.Util

     

       62
       62
       +
       

     

       63
       63
       +
       let config = Yamlrw.of_string_exn "

     

       64
       64
       +
       server:

     

       65
       65
       +
         host: localhost

     

       66
       66
       +
         port: 8080

     

       67
       67
       +
       " in

     

       68
       68
       +
       

     

       69
       69
       +
       let host = get_string (get "host" (get "server" config)) in

     

       70
       70
       +
       let port = get_int (get "port" (get "server" config)) in

     

       71
       71
       +
       Printf.printf "Server: %s:%d\n" host port

     

       72
       72
       +
       ```

     

       73
       73
       +
       

     

       74
       74
       +
       ## Command-line Tool

     

       75
       75
       +
       

     

       76
       76
       +
       The `yamlcat` binary validates and pretty-prints YAML files:

     

       77
       77
       +
       

     

       78
       78
       +
       ```bash

     

       79
       79
       +
       yamlcat input.yaml

     

       80
       80
       +
       ```

     

       81
       81
       +
       

     

       82
       82
       +
       ## API Documentation

     

       83
       83
       +
       

     

       84
       84
       +
       Build the documentation with:

     

       85
       85
       +
       

     

       86
       86
       +
       ```bash

     

       87
       87
       +
       opam exec -- dune build @doc

     

       88
       88
       +
       ```

     

       89
       89
       +
       

     

       90
       90
       +
       ## License

     

       91
       91
       +
       

     

       92
       92
       +
       ISC License - see [LICENSE.md](LICENSE.md) for details.

     

       93
       93
       +
       

     

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

bin/dune

···

       1
       1
       +
       (executable

     

       2
       2
       +
        (name yamlcat)

     

       3
       3
       +
        (package yamlrw)

     

       4
       4
       +
        (libraries cmdliner yamlrw)

     

       5
       5
       +
        (public_name yamlcat))

+197

bin/yamlcat.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
       +
       (** yamlcat - parse and reprint YAML files *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Cmdliner

     

       9
       9
       +
       

     

       10
       10
       +
       type output_format = Yaml | Json | Flow | Debug

     

       11
       11
       +
       

     

       12
       12
       +
       let rec json_to_string buf (v : Yamlrw.value) =

     

       13
       13
       +
         match v with

     

       14
       14
       +
         | `Null -> Buffer.add_string buf "null"

     

       15
       15
       +
         | `Bool b -> Buffer.add_string buf (if b then "true" else "false")

     

       16
       16
       +
         | `Float f ->

     

       17
       17
       +
             if Float.is_integer f && Float.abs f < 1e15 then

     

       18
       18
       +
               Buffer.add_string buf (Printf.sprintf "%.0f" f)

     

       19
       19
       +
             else

     

       20
       20
       +
               Buffer.add_string buf (Printf.sprintf "%g" f)

     

       21
       21
       +
         | `String s -> Buffer.add_string buf (Printf.sprintf "%S" s)

     

       22
       22
       +
         | `A items ->

     

       23
       23
       +
             Buffer.add_char buf '[';

     

       24
       24
       +
             List.iteri (fun i item ->

     

       25
       25
       +
               if i > 0 then Buffer.add_string buf ", ";

     

       26
       26
       +
               json_to_string buf item

     

       27
       27
       +
             ) items;

     

       28
       28
       +
             Buffer.add_char buf ']'

     

       29
       29
       +
         | `O pairs ->

     

       30
       30
       +
             Buffer.add_char buf '{';

     

       31
       31
       +
             List.iteri (fun i (k, v) ->

     

       32
       32
       +
               if i > 0 then Buffer.add_string buf ", ";

     

       33
       33
       +
               Buffer.add_string buf (Printf.sprintf "%S: " k);

     

       34
       34
       +
               json_to_string buf v

     

       35
       35
       +
             ) pairs;

     

       36
       36
       +
             Buffer.add_char buf '}'

     

       37
       37
       +
       

     

       38
       38
       +
       let value_to_json v =

     

       39
       39
       +
         let buf = Buffer.create 256 in

     

       40
       40
       +
         json_to_string buf v;

     

       41
       41
       +
         Buffer.contents buf

     

       42
       42
       +
       

     

       43
       43
       +
       let process_string ~format ~resolve_aliases ~max_nodes ~max_depth content =

     

       44
       44
       +
         try

     

       45
       45
       +
           (* Always parse as multi-document stream *)

     

       46
       46
       +
           let documents = Yamlrw.documents_of_string content in

     

       47
       47
       +
       

     

       48
       48
       +
           match format with

     

       49
       49
       +
           | Yaml ->

     

       50
       50
       +
               (* Convert through Value to apply tag-based type coercion *)

     

       51
       51
       +
               let first = ref true in

     

       52
       52
       +
               List.iter (fun (doc : Yamlrw.document) ->

     

       53
       53
       +
                 if not !first then print_string "---\n";

     

       54
       54
       +
                 first := false;

     

       55
       55
       +
                 match doc.root with

     

       56
       56
       +
                 | None -> print_endline ""

     

       57
       57
       +
                 | Some yaml ->

     

       58
       58
       +
                     let value = Yamlrw.to_json ~resolve_aliases ~max_nodes ~max_depth yaml in

     

       59
       59
       +
                     print_string (Yamlrw.to_string value)

     

       60
       60
       +
               ) documents

     

       61
       61
       +
           | Flow ->

     

       62
       62
       +
               (* Convert through Value to apply tag-based type coercion *)

     

       63
       63
       +
               let first = ref true in

     

       64
       64
       +
               List.iter (fun (doc : Yamlrw.document) ->

     

       65
       65
       +
                 if not !first then print_string "---\n";

     

       66
       66
       +
                 first := false;

     

       67
       67
       +
                 match doc.root with

     

       68
       68
       +
                 | None -> print_endline ""

     

       69
       69
       +
                 | Some yaml ->

     

       70
       70
       +
                     let value = Yamlrw.to_json ~resolve_aliases ~max_nodes ~max_depth yaml in

     

       71
       71
       +
                     print_string (Yamlrw.to_string ~layout_style:`Flow value)

     

       72
       72
       +
               ) documents

     

       73
       73
       +
           | Json ->

     

       74
       74
       +
               let first = ref true in

     

       75
       75
       +
               List.iter (fun (doc : Yamlrw.document) ->

     

       76
       76
       +
                 match doc.root with

     

       77
       77
       +
                 | None -> ()

     

       78
       78
       +
                 | Some yaml ->

     

       79
       79
       +
                     if not !first then print_endline "---";

     

       80
       80
       +
                     first := false;

     

       81
       81
       +
                     let value = Yamlrw.to_json ~resolve_aliases ~max_nodes ~max_depth yaml in

     

       82
       82
       +
                     print_endline (value_to_json value)

     

       83
       83
       +
               ) documents

     

       84
       84
       +
           | Debug ->

     

       85
       85
       +
               List.iteri (fun i (doc : Yamlrw.document) ->

     

       86
       86
       +
                 Format.printf "Document %d:@." (i + 1);

     

       87
       87
       +
                 (* Convert back to Document.t for printing *)

     

       88
       88
       +
                 let doc' : Yamlrw.Document.t = {

     

       89
       89
       +
                   Yamlrw.Document.version = doc.version;

     

       90
       90
       +
                   Yamlrw.Document.tags = doc.tags;

     

       91
       91
       +
                   Yamlrw.Document.root = (doc.root :> Yamlrw.Yaml.t option);

     

       92
       92
       +
                   Yamlrw.Document.implicit_start = doc.implicit_start;

     

       93
       93
       +
                   Yamlrw.Document.implicit_end = doc.implicit_end;

     

       94
       94
       +
                 } in

     

       95
       95
       +
                 Format.printf "%a@." Yamlrw.Document.pp doc'

     

       96
       96
       +
               ) documents

     

       97
       97
       +
         with

     

       98
       98
       +
         | Yamlrw.Yamlrw_error e ->

     

       99
       99
       +
             Printf.eprintf "Error: %s\n" (Yamlrw.Error.to_string e);

     

       100
       100
       +
             exit 1

     

       101
       101
       +
       

     

       102
       102
       +
       let process_file ~format ~resolve_aliases ~max_nodes ~max_depth filename =

     

       103
       103
       +
         let content =

     

       104
       104
       +
           if filename = "-" then

     

       105
       105
       +
             In_channel.input_all In_channel.stdin

     

       106
       106
       +
           else

     

       107
       107
       +
             In_channel.with_open_text filename In_channel.input_all

     

       108
       108
       +
         in

     

       109
       109
       +
         process_string ~format ~resolve_aliases ~max_nodes ~max_depth content

     

       110
       110
       +
       

     

       111
       111
       +
       let run format _all resolve_aliases max_nodes max_depth files =

     

       112
       112
       +
         let files = if files = [] then ["-"] else files in

     

       113
       113
       +
         List.iter (process_file ~format ~resolve_aliases ~max_nodes ~max_depth) files;

     

       114
       114
       +
         `Ok ()

     

       115
       115
       +
       

     

       116
       116
       +
       (* Command-line arguments *)

     

       117
       117
       +
       

     

       118
       118
       +
       let format_arg =

     

       119
       119
       +
         let doc = "Output format: yaml (default), json, flow, or debug." in

     

       120
       120
       +
         let formats = [

     

       121
       121
       +
           ("yaml", Yaml);

     

       122
       122
       +
           ("json", Json);

     

       123
       123
       +
           ("flow", Flow);

     

       124
       124
       +
           ("debug", Debug);

     

       125
       125
       +
         ] in

     

       126
       126
       +
         Arg.(value & opt (enum formats) Yaml & info ["format"; "f"] ~docv:"FORMAT" ~doc)

     

       127
       127
       +
       

     

       128
       128
       +
       let json_arg =

     

       129
       129
       +
         let doc = "Output as JSON (shorthand for --format=json)." in

     

       130
       130
       +
         Arg.(value & flag & info ["json"] ~doc)

     

       131
       131
       +
       

     

       132
       132
       +
       let flow_arg =

     

       133
       133
       +
         let doc = "Output in flow style (shorthand for --format=flow)." in

     

       134
       134
       +
         Arg.(value & flag & info ["flow"] ~doc)

     

       135
       135
       +
       

     

       136
       136
       +
       let debug_arg =

     

       137
       137
       +
         let doc = "Output internal representation (shorthand for --format=debug)." in

     

       138
       138
       +
         Arg.(value & flag & info ["debug"] ~doc)

     

       139
       139
       +
       

     

       140
       140
       +
       let all_arg =

     

       141
       141
       +
         let doc = "Output all documents (for multi-document YAML)." in

     

       142
       142
       +
         Arg.(value & flag & info ["all"; "a"] ~doc)

     

       143
       143
       +
       

     

       144
       144
       +
       let no_resolve_aliases_arg =

     

       145
       145
       +
         let doc = "Don't resolve aliases (keep them as references)." in

     

       146
       146
       +
         Arg.(value & flag & info ["no-resolve-aliases"] ~doc)

     

       147
       147
       +
       

     

       148
       148
       +
       let max_nodes_arg =

     

       149
       149
       +
         let doc = "Maximum number of nodes during alias expansion (default: 10000000). \

     

       150
       150
       +
                    Protection against billion laughs attack." in

     

       151
       151
       +
         Arg.(value & opt int Yamlrw.default_max_alias_nodes & info ["max-nodes"] ~docv:"N" ~doc)

     

       152
       152
       +
       

     

       153
       153
       +
       let max_depth_arg =

     

       154
       154
       +
         let doc = "Maximum alias nesting depth (default: 100). \

     

       155
       155
       +
                    Protection against deeply nested alias chains." in

     

       156
       156
       +
         Arg.(value & opt int Yamlrw.default_max_alias_depth & info ["max-depth"] ~docv:"N" ~doc)

     

       157
       157
       +
       

     

       158
       158
       +
       let files_arg =

     

       159
       159
       +
         let doc = "YAML file(s) to process. Use '-' for stdin." in

     

       160
       160
       +
         Arg.(value & pos_all file [] & info [] ~docv:"FILE" ~doc)

     

       161
       161
       +
       

     

       162
       162
       +
       let combined_format format json flow debug =

     

       163
       163
       +
         if json then Json

     

       164
       164
       +
         else if flow then Flow

     

       165
       165
       +
         else if debug then Debug

     

       166
       166
       +
         else format

     

       167
       167
       +
       

     

       168
       168
       +
       let term =

     

       169
       169
       +
         let combine format json flow debug all no_resolve max_nodes max_depth files =

     

       170
       170
       +
           let format = combined_format format json flow debug in

     

       171
       171
       +
           let resolve_aliases = not no_resolve in

     

       172
       172
       +
           run format all resolve_aliases max_nodes max_depth files

     

       173
       173
       +
         in

     

       174
       174
       +
         Term.(ret (const combine $ format_arg $ json_arg $ flow_arg $ debug_arg $

     

       175
       175
       +
                    all_arg $ no_resolve_aliases_arg $ max_nodes_arg $ max_depth_arg $ files_arg))

     

       176
       176
       +
       

     

       177
       177
       +
       let info =

     

       178
       178
       +
         let doc = "Parse and reprint YAML files" in

     

       179
       179
       +
         let man = [

     

       180
       180
       +
           `S Manpage.s_description;

     

       181
       181
       +
           `P "$(tname) parses YAML files and reprints them in various formats. \

     

       182
       182
       +
               It can be used to validate YAML, convert between styles, or convert to JSON.";

     

       183
       183
       +
           `S Manpage.s_examples;

     

       184
       184
       +
           `P "Parse and reprint a YAML file:";

     

       185
       185
       +
           `Pre "  $(tname) config.yaml";

     

       186
       186
       +
           `P "Convert YAML to JSON:";

     

       187
       187
       +
           `Pre "  $(tname) --json config.yaml";

     

       188
       188
       +
           `P "Process multi-document YAML:";

     

       189
       189
       +
           `Pre "  $(tname) --all multi.yaml";

     

       190
       190
       +
           `P "Limit alias expansion (protection against malicious YAML):";

     

       191
       191
       +
           `Pre "  $(tname) --max-nodes 1000 --max-depth 10 untrusted.yaml";

     

       192
       192
       +
           `S Manpage.s_bugs;

     

       193
       193
       +
           `P "Report bugs at https://github.com/avsm/ocaml-yaml/issues";

     

       194
       194
       +
         ] in

     

       195
       195
       +
         Cmd.info "yamlcat" ~version:"0.1.0" ~doc ~man

     

       196
       196
       +
       

     

       197
       197
       +
       let () = exit (Cmd.eval (Cmd.v info term))

dune

···

       1
       1
       +
       ; Root dune file

     

       2
       2
       +
       

     

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

     

       4
       4
       +
       (data_only_dirs third_party)

+52

dune-project

···

       1
       1
       +
       (lang dune 3.18)

     

       2
       2
       +
       (name yamlrw)

     

       3
       3
       +
       

     

       4
       4
       +
       (generate_opam_files true)

     

       5
       5
       +
       

     

       6
       6
       +
       (license ISC)

     

       7
       7
       +
       (authors "Anil Madhavapeddy")

     

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

     

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

     

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

     

       11
       11
       +
       (maintenance_intent "(latest)")

     

       12
       12
       +
       

     

       13
       13
       +
       (package

     

       14
       14
       +
        (name yamlrw)

     

       15
       15
       +
        (synopsis "Pure OCaml YAML 1.2 parser and emitter")

     

       16
       16
       +
        (description "\

     

       17
       17
       +
       Yamlrw is a pure OCaml implementation of YAML 1.2 parsing and emission. \

     

       18
       18
       +
       It provides both a high-level JSON-compatible interface for simple data interchange \

     

       19
       19
       +
       and a lower-level streaming API for fine-grained control over parsing and emission. \

     

       20
       20
       +
       The library works on all OCaml platforms without C dependencies.")

     

       21
       21
       +
        (depends

     

       22
       22
       +
         (ocaml (>= 4.14.0))

     

       23
       23
       +
         bytesrw

     

       24
       24
       +
         cmdliner

     

       25
       25
       +
         (odoc :with-doc)

     

       26
       26
       +
         (alcotest :with-test)))

     

       27
       27
       +
       

     

       28
       28
       +
       (package

     

       29
       29
       +
        (name yamlrw-unix)

     

       30
       30
       +
        (synopsis "Unix I/O for Yamlrw")

     

       31
       31
       +
        (description "\

     

       32
       32
       +
       Unix file and channel operations for Yamlrw. \

     

       33
       33
       +
       Provides convenient functions for reading and writing YAML files using Unix I/O.")

     

       34
       34
       +
        (depends

     

       35
       35
       +
         (ocaml (>= 4.14.0))

     

       36
       36
       +
         yamlrw

     

       37
       37
       +
         bytesrw

     

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

     

       39
       39
       +
       

     

       40
       40
       +
       (package

     

       41
       41
       +
        (name yamlrw-eio)

     

       42
       42
       +
        (synopsis "Eio support for Yamlrw")

     

       43
       43
       +
        (description "\

     

       44
       44
       +
       Eio-based streaming I/O for Yamlrw. \

     

       45
       45
       +
       Provides efficient async YAML parsing and emission using the Eio effects-based concurrency library. \

     

       46
       46
       +
       Requires OCaml 5.0 or later.")

     

       47
       47
       +
        (depends

     

       48
       48
       +
         (ocaml (>= 5.0.0))

     

       49
       49
       +
         yamlrw

     

       50
       50
       +
         bytesrw-eio

     

       51
       51
       +
         (eio (>= 1.1))

     

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

+46

lib/char_class.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
       +
       (** Character classification for YAML parsing *)

     

       7
       7
       +
       

     

       8
       8
       +
       (** Line break characters *)

     

       9
       9
       +
       let is_break c = c = '\n' || c = '\r'

     

       10
       10
       +
       

     

       11
       11
       +
       (** Blank (space or tab) *)

     

       12
       12
       +
       let is_blank c = c = ' ' || c = '\t'

     

       13
       13
       +
       

     

       14
       14
       +
       (** Whitespace (break or blank) *)

     

       15
       15
       +
       let is_whitespace c = is_break c || is_blank c

     

       16
       16
       +
       

     

       17
       17
       +
       (** Decimal digit *)

     

       18
       18
       +
       let is_digit c = c >= '0' && c <= '9'

     

       19
       19
       +
       

     

       20
       20
       +
       (** Hexadecimal digit *)

     

       21
       21
       +
       let is_hex c =

     

       22
       22
       +
         (c >= '0' && c <= '9') ||

     

       23
       23
       +
         (c >= 'a' && c <= 'f') ||

     

       24
       24
       +
         (c >= 'A' && c <= 'F')

     

       25
       25
       +
       

     

       26
       26
       +
       (** Alphabetic character *)

     

       27
       27
       +
       let is_alpha c =

     

       28
       28
       +
         (c >= 'a' && c <= 'z') ||

     

       29
       29
       +
         (c >= 'A' && c <= 'Z')

     

       30
       30
       +
       

     

       31
       31
       +
       (** Alphanumeric character *)

     

       32
       32
       +
       let is_alnum c = is_alpha c || is_digit c

     

       33
       33
       +
       

     

       34
       34
       +
       (** YAML indicator characters *)

     

       35
       35
       +
       let is_indicator c =

     

       36
       36
       +
         match c with

     

       37
       37
       +
         | '-' | '?' | ':' | ',' | '[' | ']' | '{' | '}'

     

       38
       38
       +
         | '#' | '&' | '*' | '!' | '|' | '>' | '\'' | '"'

     

       39
       39
       +
         | '%' | '@' | '`' -> true

     

       40
       40
       +
         | _ -> false

     

       41
       41
       +
       

     

       42
       42
       +
       (** Flow context indicator characters *)

     

       43
       43
       +
       let is_flow_indicator c =

     

       44
       44
       +
         match c with

     

       45
       45
       +
         | ',' | '[' | ']' | '{' | '}' -> true

     

       46
       46
       +
         | _ -> false

+31

lib/chomping.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
       +
       (** Block scalar chomping indicators *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t =

     

       9
       9
       +
         | Strip (** Remove final line break and trailing empty lines *)

     

       10
       10
       +
         | Clip  (** Keep final line break, remove trailing empty lines (default) *)

     

       11
       11
       +
         | Keep  (** Keep final line break and trailing empty lines *)

     

       12
       12
       +
       

     

       13
       13
       +
       let to_string = function

     

       14
       14
       +
         | Strip -> "strip"

     

       15
       15
       +
         | Clip -> "clip"

     

       16
       16
       +
         | Keep -> "keep"

     

       17
       17
       +
       

     

       18
       18
       +
       let pp fmt t =

     

       19
       19
       +
         Format.pp_print_string fmt (to_string t)

     

       20
       20
       +
       

     

       21
       21
       +
       let of_char = function

     

       22
       22
       +
         | '-' -> Some Strip

     

       23
       23
       +
         | '+' -> Some Keep

     

       24
       24
       +
         | _ -> None

     

       25
       25
       +
       

     

       26
       26
       +
       let to_char = function

     

       27
       27
       +
         | Strip -> Some '-'

     

       28
       28
       +
         | Clip -> None

     

       29
       29
       +
         | Keep -> Some '+'

     

       30
       30
       +
       

     

       31
       31
       +
       let equal a b = a = b

+59

lib/document.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
       +
       (** YAML document with directives and content *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t = {

     

       9
       9
       +
         version : (int * int) option;

     

       10
       10
       +
         tags : (string * string) list;

     

       11
       11
       +
         root : Yaml.t option;

     

       12
       12
       +
         implicit_start : bool;

     

       13
       13
       +
         implicit_end : bool;

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       let make

     

       17
       17
       +
           ?(version : (int * int) option)

     

       18
       18
       +
           ?(tags : (string * string) list = [])

     

       19
       19
       +
           ?(implicit_start = true)

     

       20
       20
       +
           ?(implicit_end = true)

     

       21
       21
       +
           root =

     

       22
       22
       +
         { version; tags; root; implicit_start; implicit_end }

     

       23
       23
       +
       

     

       24
       24
       +
       let version t = t.version

     

       25
       25
       +
       let tags t = t.tags

     

       26
       26
       +
       let root t = t.root

     

       27
       27
       +
       let implicit_start t = t.implicit_start

     

       28
       28
       +
       let implicit_end t = t.implicit_end

     

       29
       29
       +
       

     

       30
       30
       +
       let with_version version t = { t with version = Some version }

     

       31
       31
       +
       let with_tags tags t = { t with tags }

     

       32
       32
       +
       let with_root root t = { t with root = Some root }

     

       33
       33
       +
       

     

       34
       34
       +
       let pp fmt t =

     

       35
       35
       +
         Format.fprintf fmt "@[<v 2>document(@,";

     

       36
       36
       +
         (match t.version with

     

       37
       37
       +
          | Some (maj, min) -> Format.fprintf fmt "version=%d.%d,@ " maj min

     

       38
       38
       +
          | None -> ());

     

       39
       39
       +
         if t.tags <> [] then begin

     

       40
       40
       +
           Format.fprintf fmt "tags=[";

     

       41
       41
       +
           List.iteri (fun i (h, p) ->

     

       42
       42
       +
             if i > 0 then Format.fprintf fmt ", ";

     

       43
       43
       +
             Format.fprintf fmt "%s -> %s" h p

     

       44
       44
       +
           ) t.tags;

     

       45
       45
       +
           Format.fprintf fmt "],@ "

     

       46
       46
       +
         end;

     

       47
       47
       +
         Format.fprintf fmt "implicit_start=%b,@ " t.implicit_start;

     

       48
       48
       +
         Format.fprintf fmt "implicit_end=%b,@ " t.implicit_end;

     

       49
       49
       +
         (match t.root with

     

       50
       50
       +
          | Some root -> Format.fprintf fmt "root=%a" Yaml.pp root

     

       51
       51
       +
          | None -> Format.fprintf fmt "root=<empty>");

     

       52
       52
       +
         Format.fprintf fmt "@]@,)"

     

       53
       53
       +
       

     

       54
       54
       +
       let equal a b =

     

       55
       55
       +
         Option.equal (fun (a1, a2) (b1, b2) -> a1 = b1 && a2 = b2) a.version b.version &&

     

       56
       56
       +
         List.equal (fun (h1, p1) (h2, p2) -> h1 = h2 && p1 = p2) a.tags b.tags &&

     

       57
       57
       +
         Option.equal Yaml.equal a.root b.root &&

     

       58
       58
       +
         a.implicit_start = b.implicit_start &&

     

       59
       59
       +
         a.implicit_end = b.implicit_end

+35

lib/dune

···

       1
       1
       +
       (library

     

       2
       2
       +
        (name yamlrw)

     

       3
       3
       +
        (public_name yamlrw)

     

       4
       4
       +
        (libraries bytesrw)

     

       5
       5
       +
        (modules

     

       6
       6
       +
         ; Core types

     

       7
       7
       +
         position

     

       8
       8
       +
         span

     

       9
       9
       +
         error

     

       10
       10
       +
         encoding

     

       11
       11
       +
         scalar_style

     

       12
       12
       +
         layout_style

     

       13
       13
       +
         chomping

     

       14
       14
       +
         char_class

     

       15
       15
       +
         quoting

     

       16
       16
       +
         ; Streaming

     

       17
       17
       +
         input

     

       18
       18
       +
         token

     

       19
       19
       +
         scanner

     

       20
       20
       +
         event

     

       21
       21
       +
         parser

     

       22
       22
       +
         emitter

     

       23
       23
       +
         ; Value types

     

       24
       24
       +
         tag

     

       25
       25
       +
         value

     

       26
       26
       +
         scalar

     

       27
       27
       +
         sequence

     

       28
       28
       +
         mapping

     

       29
       29
       +
         yaml

     

       30
       30
       +
         document

     

       31
       31
       +
         ; Conversion

     

       32
       32
       +
         loader

     

       33
       33
       +
         serialize

     

       34
       34
       +
         ; Main module

     

       35
       35
       +
         yamlrw))

lib/eio/dune

···

       1
       1
       +
       (library

     

       2
       2
       +
        (name yamlrw_eio)

     

       3
       3
       +
        (public_name yamlrw-eio)

     

       4
       4
       +
        (libraries yamlrw bytesrw-eio eio))

+268

lib/eio/yamlrw_eio.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
       +
       (** Yamlrw Eio - Streaming YAML parsing and emitting with Eio

     

       7
       7
       +
       

     

       8
       8
       +
           This module provides Eio-compatible streaming YAML parsing and emitting.

     

       9
       9
       +
           It uses bytesrw adapters to convert Eio sources/sinks to the standard

     

       10
       10
       +
           YAML scanner/parser/emitter, eliminating code duplication. *)

     

       11
       11
       +
       

     

       12
       12
       +
       open Yamlrw

     

       13
       13
       +
       

     

       14
       14
       +
       (** {1 Types} *)

     

       15
       15
       +
       

     

       16
       16
       +
       type value = Value.t

     

       17
       17
       +
       type yaml = Yaml.t

     

       18
       18
       +
       type document = Document.t

     

       19
       19
       +
       type event = Event.t

     

       20
       20
       +
       

     

       21
       21
       +
       (** {1 Reading from Eio Sources} *)

     

       22
       22
       +
       

     

       23
       23
       +
       module Read = struct

     

       24
       24
       +
         (** Parse YAML from Eio sources/flows *)

     

       25
       25
       +
       

     

       26
       26
       +
         (** Create a scanner from an Eio flow *)

     

       27
       27
       +
         let scanner_of_flow flow =

     

       28
       28
       +
           let reader = Bytesrw_eio.bytes_reader_of_flow flow in

     

       29
       29
       +
           let input = Input.of_reader reader in

     

       30
       30
       +
           Scanner.of_input input

     

       31
       31
       +
       

     

       32
       32
       +
         (** Create a parser from an Eio flow *)

     

       33
       33
       +
         let parser_of_flow flow =

     

       34
       34
       +
           Parser.of_scanner (scanner_of_flow flow)

     

       35
       35
       +
       

     

       36
       36
       +
         (** Parse a JSON-compatible value from an Eio flow.

     

       37
       37
       +
       

     

       38
       38
       +
             @param resolve_aliases Whether to expand aliases (default: true)

     

       39
       39
       +
             @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       40
       40
       +
             @param max_depth Maximum alias nesting depth (default: 100) *)

     

       41
       41
       +
         let value

     

       42
       42
       +
             ?(resolve_aliases = true)

     

       43
       43
       +
             ?(max_nodes = Yaml.default_max_alias_nodes)

     

       44
       44
       +
             ?(max_depth = Yaml.default_max_alias_depth)

     

       45
       45
       +
             flow =

     

       46
       46
       +
           let parser = parser_of_flow flow in

     

       47
       47
       +
           Loader.value_of_parser

     

       48
       48
       +
             ~resolve_aliases ~max_nodes ~max_depth

     

       49
       49
       +
             (fun () -> Parser.next parser)

     

       50
       50
       +
       

     

       51
       51
       +
         (** Parse a full YAML value from an Eio flow.

     

       52
       52
       +
       

     

       53
       53
       +
             By default, aliases are NOT resolved, preserving the document structure.

     

       54
       54
       +
       

     

       55
       55
       +
             @param resolve_aliases Whether to expand aliases (default: false)

     

       56
       56
       +
             @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       57
       57
       +
             @param max_depth Maximum alias nesting depth (default: 100) *)

     

       58
       58
       +
         let yaml

     

       59
       59
       +
             ?(resolve_aliases = false)

     

       60
       60
       +
             ?(max_nodes = Yaml.default_max_alias_nodes)

     

       61
       61
       +
             ?(max_depth = Yaml.default_max_alias_depth)

     

       62
       62
       +
             flow =

     

       63
       63
       +
           let parser = parser_of_flow flow in

     

       64
       64
       +
           Loader.yaml_of_parser

     

       65
       65
       +
             ~resolve_aliases ~max_nodes ~max_depth

     

       66
       66
       +
             (fun () -> Parser.next parser)

     

       67
       67
       +
       

     

       68
       68
       +
         (** Parse multiple YAML documents from an Eio flow. *)

     

       69
       69
       +
         let documents flow =

     

       70
       70
       +
           let parser = parser_of_flow flow in

     

       71
       71
       +
           Loader.documents_of_parser (fun () -> Parser.next parser)

     

       72
       72
       +
       

     

       73
       73
       +
         (** {2 Event-Based Streaming} *)

     

       74
       74
       +
       

     

       75
       75
       +
         (** A streaming event reader backed by a flow *)

     

       76
       76
       +
         type event_reader = {

     

       77
       77
       +
           parser : Parser.t;

     

       78
       78
       +
         }

     

       79
       79
       +
       

     

       80
       80
       +
         (** Create an event reader from an Eio flow.

     

       81
       81
       +
             This reads data incrementally as events are requested. *)

     

       82
       82
       +
         let event_reader flow =

     

       83
       83
       +
           { parser = parser_of_flow flow }

     

       84
       84
       +
       

     

       85
       85
       +
         (** Get the next event from an event reader.

     

       86
       86
       +
             Returns [None] when parsing is complete. *)

     

       87
       87
       +
         let next_event reader =

     

       88
       88
       +
           Parser.next reader.parser

     

       89
       89
       +
       

     

       90
       90
       +
         (** Iterate over all events from a flow.

     

       91
       91
       +
       

     

       92
       92
       +
             @param f Called with each event and its source span *)

     

       93
       93
       +
         let iter_events f flow =

     

       94
       94
       +
           let parser = parser_of_flow flow in

     

       95
       95
       +
           Parser.iter (fun ev -> f ev.event ev.span) parser

     

       96
       96
       +
       

     

       97
       97
       +
         (** Fold over all events from a flow. *)

     

       98
       98
       +
         let fold_events f init flow =

     

       99
       99
       +
           let parser = parser_of_flow flow in

     

       100
       100
       +
           let rec loop acc =

     

       101
       101
       +
             match Parser.next parser with

     

       102
       102
       +
             | Some ev -> loop (f acc ev.event)

     

       103
       103
       +
             | None -> acc

     

       104
       104
       +
           in

     

       105
       105
       +
           loop init

     

       106
       106
       +
       

     

       107
       107
       +
         (** Iterate over documents from a flow, calling [f] for each document. *)

     

       108
       108
       +
         let iter_documents f flow =

     

       109
       109
       +
           let parser = parser_of_flow flow in

     

       110
       110
       +
           Loader.iter_documents_parser f (fun () -> Parser.next parser)

     

       111
       111
       +
       

     

       112
       112
       +
         (** Fold over documents from a flow. *)

     

       113
       113
       +
         let fold_documents f init flow =

     

       114
       114
       +
           let parser = parser_of_flow flow in

     

       115
       115
       +
           Loader.fold_documents_parser f init (fun () -> Parser.next parser)

     

       116
       116
       +
       end

     

       117
       117
       +
       

     

       118
       118
       +
       (** {1 Writing to Eio Sinks} *)

     

       119
       119
       +
       

     

       120
       120
       +
       module Write = struct

     

       121
       121
       +
         (** Emit YAML to Eio sinks/flows using true streaming output. *)

     

       122
       122
       +
       

     

       123
       123
       +
         (** Write a JSON-compatible value to an Eio flow.

     

       124
       124
       +
       

     

       125
       125
       +
             Uses the emitter's native Writer support for streaming output.

     

       126
       126
       +
       

     

       127
       127
       +
             @param encoding Output encoding (default: UTF-8)

     

       128
       128
       +
             @param scalar_style Preferred scalar style (default: Any)

     

       129
       129
       +
             @param layout_style Preferred layout style (default: Any) *)

     

       130
       130
       +
         let value

     

       131
       131
       +
             ?(encoding = `Utf8)

     

       132
       132
       +
             ?(scalar_style = `Any)

     

       133
       133
       +
             ?(layout_style = `Any)

     

       134
       134
       +
             flow

     

       135
       135
       +
             (v : value) =

     

       136
       136
       +
           let config = { Emitter.default_config with encoding; scalar_style; layout_style } in

     

       137
       137
       +
           let writer = Bytesrw_eio.bytes_writer_of_flow flow in

     

       138
       138
       +
           Serialize.value_to_writer ~config writer v

     

       139
       139
       +
       

     

       140
       140
       +
         (** Write a full YAML value to an Eio flow.

     

       141
       141
       +
       

     

       142
       142
       +
             @param encoding Output encoding (default: UTF-8)

     

       143
       143
       +
             @param scalar_style Preferred scalar style (default: Any)

     

       144
       144
       +
             @param layout_style Preferred layout style (default: Any) *)

     

       145
       145
       +
         let yaml

     

       146
       146
       +
             ?(encoding = `Utf8)

     

       147
       147
       +
             ?(scalar_style = `Any)

     

       148
       148
       +
             ?(layout_style = `Any)

     

       149
       149
       +
             flow

     

       150
       150
       +
             (v : yaml) =

     

       151
       151
       +
           let config = { Emitter.default_config with encoding; scalar_style; layout_style } in

     

       152
       152
       +
           let writer = Bytesrw_eio.bytes_writer_of_flow flow in

     

       153
       153
       +
           Serialize.yaml_to_writer ~config writer v

     

       154
       154
       +
       

     

       155
       155
       +
         (** Write multiple YAML documents to an Eio flow.

     

       156
       156
       +
       

     

       157
       157
       +
             @param encoding Output encoding (default: UTF-8)

     

       158
       158
       +
             @param scalar_style Preferred scalar style (default: Any)

     

       159
       159
       +
             @param layout_style Preferred layout style (default: Any)

     

       160
       160
       +
             @param resolve_aliases Whether to expand aliases (default: true) *)

     

       161
       161
       +
         let documents

     

       162
       162
       +
             ?(encoding = `Utf8)

     

       163
       163
       +
             ?(scalar_style = `Any)

     

       164
       164
       +
             ?(layout_style = `Any)

     

       165
       165
       +
             ?(resolve_aliases = true)

     

       166
       166
       +
             flow

     

       167
       167
       +
             docs =

     

       168
       168
       +
           let config = { Emitter.default_config with encoding; scalar_style; layout_style } in

     

       169
       169
       +
           let writer = Bytesrw_eio.bytes_writer_of_flow flow in

     

       170
       170
       +
           Serialize.documents_to_writer ~config ~resolve_aliases writer docs

     

       171
       171
       +
       

     

       172
       172
       +
         (** {2 Event-Based Streaming} *)

     

       173
       173
       +
       

     

       174
       174
       +
         (** A streaming event writer that writes directly to a flow *)

     

       175
       175
       +
         type event_writer = {

     

       176
       176
       +
           emitter : Emitter.t;

     

       177
       177
       +
         }

     

       178
       178
       +
       

     

       179
       179
       +
         (** Create an event writer that writes directly to a flow.

     

       180
       180
       +
             Events are written incrementally as they are emitted.

     

       181
       181
       +
       

     

       182
       182
       +
             @param encoding Output encoding (default: UTF-8)

     

       183
       183
       +
             @param scalar_style Preferred scalar style (default: Any)

     

       184
       184
       +
             @param layout_style Preferred layout style (default: Any) *)

     

       185
       185
       +
         let event_writer

     

       186
       186
       +
             ?(encoding = `Utf8)

     

       187
       187
       +
             ?(scalar_style = `Any)

     

       188
       188
       +
             ?(layout_style = `Any)

     

       189
       189
       +
             flow =

     

       190
       190
       +
           let config = { Emitter.default_config with encoding; scalar_style; layout_style } in

     

       191
       191
       +
           let writer = Bytesrw_eio.bytes_writer_of_flow flow in

     

       192
       192
       +
           { emitter = Emitter.of_writer ~config writer }

     

       193
       193
       +
       

     

       194
       194
       +
         (** Emit a single event to the writer. *)

     

       195
       195
       +
         let emit ew ev =

     

       196
       196
       +
           Emitter.emit ew.emitter ev

     

       197
       197
       +
       

     

       198
       198
       +
         (** Flush the writer by sending end-of-data. *)

     

       199
       199
       +
         let flush ew =

     

       200
       200
       +
           Emitter.flush ew.emitter

     

       201
       201
       +
       

     

       202
       202
       +
         (** Emit events from a list to a flow. *)

     

       203
       203
       +
         let emit_all flow events =

     

       204
       204
       +
           let ew = event_writer flow in

     

       205
       205
       +
           List.iter (emit ew) events;

     

       206
       206
       +
           flush ew

     

       207
       207
       +
       end

     

       208
       208
       +
       

     

       209
       209
       +
       (** {1 Convenience Functions} *)

     

       210
       210
       +
       

     

       211
       211
       +
       (** Read a value from a file path *)

     

       212
       212
       +
       let of_file

     

       213
       213
       +
           ?(resolve_aliases = true)

     

       214
       214
       +
           ?(max_nodes = Yaml.default_max_alias_nodes)

     

       215
       215
       +
           ?(max_depth = Yaml.default_max_alias_depth)

     

       216
       216
       +
           ~fs

     

       217
       217
       +
           path =

     

       218
       218
       +
         Eio.Path.with_open_in Eio.Path.(fs / path) @@ fun flow ->

     

       219
       219
       +
         Read.value ~resolve_aliases ~max_nodes ~max_depth flow

     

       220
       220
       +
       

     

       221
       221
       +
       (** Read full YAML from a file path *)

     

       222
       222
       +
       let yaml_of_file

     

       223
       223
       +
           ?(resolve_aliases = false)

     

       224
       224
       +
           ?(max_nodes = Yaml.default_max_alias_nodes)

     

       225
       225
       +
           ?(max_depth = Yaml.default_max_alias_depth)

     

       226
       226
       +
           ~fs

     

       227
       227
       +
           path =

     

       228
       228
       +
         Eio.Path.with_open_in Eio.Path.(fs / path) @@ fun flow ->

     

       229
       229
       +
         Read.yaml ~resolve_aliases ~max_nodes ~max_depth flow

     

       230
       230
       +
       

     

       231
       231
       +
       (** Read documents from a file path *)

     

       232
       232
       +
       let documents_of_file ~fs path =

     

       233
       233
       +
         Eio.Path.with_open_in Eio.Path.(fs / path) @@ fun flow ->

     

       234
       234
       +
         Read.documents flow

     

       235
       235
       +
       

     

       236
       236
       +
       (** Write a value to a file path *)

     

       237
       237
       +
       let to_file

     

       238
       238
       +
           ?(encoding = `Utf8)

     

       239
       239
       +
           ?(scalar_style = `Any)

     

       240
       240
       +
           ?(layout_style = `Any)

     

       241
       241
       +
           ~fs

     

       242
       242
       +
           path

     

       243
       243
       +
           v =

     

       244
       244
       +
         Eio.Path.with_open_out ~create:(`Or_truncate 0o644) Eio.Path.(fs / path) @@ fun flow ->

     

       245
       245
       +
         Write.value ~encoding ~scalar_style ~layout_style flow v

     

       246
       246
       +
       

     

       247
       247
       +
       (** Write full YAML to a file path *)

     

       248
       248
       +
       let yaml_to_file

     

       249
       249
       +
           ?(encoding = `Utf8)

     

       250
       250
       +
           ?(scalar_style = `Any)

     

       251
       251
       +
           ?(layout_style = `Any)

     

       252
       252
       +
           ~fs

     

       253
       253
       +
           path

     

       254
       254
       +
           v =

     

       255
       255
       +
         Eio.Path.with_open_out ~create:(`Or_truncate 0o644) Eio.Path.(fs / path) @@ fun flow ->

     

       256
       256
       +
         Write.yaml ~encoding ~scalar_style ~layout_style flow v

     

       257
       257
       +
       

     

       258
       258
       +
       (** Write documents to a file path *)

     

       259
       259
       +
       let documents_to_file

     

       260
       260
       +
           ?(encoding = `Utf8)

     

       261
       261
       +
           ?(scalar_style = `Any)

     

       262
       262
       +
           ?(layout_style = `Any)

     

       263
       263
       +
           ?(resolve_aliases = true)

     

       264
       264
       +
           ~fs

     

       265
       265
       +
           path

     

       266
       266
       +
           docs =

     

       267
       267
       +
         Eio.Path.with_open_out ~create:(`Or_truncate 0o644) Eio.Path.(fs / path) @@ fun flow ->

     

       268
       268
       +
         Write.documents ~encoding ~scalar_style ~layout_style ~resolve_aliases flow docs

+265

lib/eio/yamlrw_eio.mli

···

       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
       +
       (** Yamlrw Eio - Streaming YAML parsing and emitting with Eio

     

       7
       7
       +
       

     

       8
       8
       +
           This library provides Eio-based streaming support for YAML parsing

     

       9
       9
       +
           and emitting. It uses bytesrw adapters that read/write directly to

     

       10
       10
       +
           Eio flows, with bytesrw handling internal buffering.

     

       11
       11
       +
       

     

       12
       12
       +
           {2 Quick Start}

     

       13
       13
       +
       

     

       14
       14
       +
           Read YAML from a file:

     

       15
       15
       +
           {[

     

       16
       16
       +
             Eio_main.run @@ fun env ->

     

       17
       17
       +
             let fs = Eio.Stdenv.fs env in

     

       18
       18
       +
             let value = Yaml_eio.of_file ~fs "config.yaml" in

     

       19
       19
       +
             ...

     

       20
       20
       +
           ]}

     

       21
       21
       +
       

     

       22
       22
       +
           Write YAML to a flow:

     

       23
       23
       +
           {[

     

       24
       24
       +
             Eio_main.run @@ fun env ->

     

       25
       25
       +
             let fs = Eio.Stdenv.fs env in

     

       26
       26
       +
             Eio.Path.with_open_out Eio.Path.(fs / "output.yaml") @@ fun flow ->

     

       27
       27
       +
             Yaml_eio.Write.value flow (`O [("name", `String "test")])

     

       28
       28
       +
           ]}

     

       29
       29
       +
       

     

       30
       30
       +
           Stream events incrementally:

     

       31
       31
       +
           {[

     

       32
       32
       +
             Eio_main.run @@ fun env ->

     

       33
       33
       +
             let fs = Eio.Stdenv.fs env in

     

       34
       34
       +
             Eio.Path.with_open_in Eio.Path.(fs / "data.yaml") @@ fun flow ->

     

       35
       35
       +
             Yaml_eio.Read.iter_events (fun event span ->

     

       36
       36
       +
               Format.printf "Event at %a@." Yamlrw.Span.pp span

     

       37
       37
       +
             ) flow

     

       38
       38
       +
           ]}

     

       39
       39
       +
       

     

       40
       40
       +
           {2 Streaming Architecture}

     

       41
       41
       +
       

     

       42
       42
       +
           This library uses bytesrw for direct I/O with Eio flows:

     

       43
       43
       +
       

     

       44
       44
       +
           - {b Reading}: Data is read directly from the flow as the

     

       45
       45
       +
             parser requests it. Bytesrw handles internal buffering.

     

       46
       46
       +
       

     

       47
       47
       +
           - {b Writing}: Output is written directly to the flow.

     

       48
       48
       +
             Bytesrw handles chunking and buffering. *)

     

       49
       49
       +
       

     

       50
       50
       +
       (** {1 Types} *)

     

       51
       51
       +
       

     

       52
       52
       +
       type value = Yamlrw.Value.t

     

       53
       53
       +
       (** JSON-compatible YAML value *)

     

       54
       54
       +
       

     

       55
       55
       +
       type yaml = Yamlrw.Yaml.t

     

       56
       56
       +
       (** Full YAML value with metadata *)

     

       57
       57
       +
       

     

       58
       58
       +
       type document = Yamlrw.Document.t

     

       59
       59
       +
       (** YAML document with directives *)

     

       60
       60
       +
       

     

       61
       61
       +
       type event = Yamlrw.Event.t

     

       62
       62
       +
       (** Parser/emitter event *)

     

       63
       63
       +
       

     

       64
       64
       +
       (** {1 Reading from Eio Sources} *)

     

       65
       65
       +
       

     

       66
       66
       +
       module Read : sig

     

       67
       67
       +
         (** Parse YAML from Eio flows.

     

       68
       68
       +
       

     

       69
       69
       +
             All functions read data incrementally from the underlying flow,

     

       70
       70
       +
             without loading the entire file into memory first. *)

     

       71
       71
       +
       

     

       72
       72
       +
         (** {2 High-Level Parsing} *)

     

       73
       73
       +
       

     

       74
       74
       +
         val value :

     

       75
       75
       +
           ?resolve_aliases:bool ->

     

       76
       76
       +
           ?max_nodes:int ->

     

       77
       77
       +
           ?max_depth:int ->

     

       78
       78
       +
           _ Eio.Flow.source -> value

     

       79
       79
       +
         (** Parse a JSON-compatible value from an Eio flow.

     

       80
       80
       +
       

     

       81
       81
       +
             @param resolve_aliases Whether to expand aliases (default: true)

     

       82
       82
       +
             @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       83
       83
       +
             @param max_depth Maximum alias nesting depth (default: 100) *)

     

       84
       84
       +
       

     

       85
       85
       +
         val yaml :

     

       86
       86
       +
           ?resolve_aliases:bool ->

     

       87
       87
       +
           ?max_nodes:int ->

     

       88
       88
       +
           ?max_depth:int ->

     

       89
       89
       +
           _ Eio.Flow.source -> yaml

     

       90
       90
       +
         (** Parse a full YAML value from an Eio flow.

     

       91
       91
       +
       

     

       92
       92
       +
             By default, aliases are NOT resolved, preserving the document structure.

     

       93
       93
       +
       

     

       94
       94
       +
             @param resolve_aliases Whether to expand aliases (default: false)

     

       95
       95
       +
             @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       96
       96
       +
             @param max_depth Maximum alias nesting depth (default: 100) *)

     

       97
       97
       +
       

     

       98
       98
       +
         val documents : _ Eio.Flow.source -> document list

     

       99
       99
       +
         (** Parse multiple YAML documents from an Eio flow. *)

     

       100
       100
       +
       

     

       101
       101
       +
         (** {2 Event-Based Streaming} *)

     

       102
       102
       +
       

     

       103
       103
       +
         type event_reader

     

       104
       104
       +
         (** A streaming event reader backed by a flow.

     

       105
       105
       +
             Events are parsed incrementally as requested. *)

     

       106
       106
       +
       

     

       107
       107
       +
         val event_reader : _ Eio.Flow.source -> event_reader

     

       108
       108
       +
         (** Create an event reader from an Eio flow. *)

     

       109
       109
       +
       

     

       110
       110
       +
         val next_event : event_reader -> Yamlrw.Event.spanned option

     

       111
       111
       +
         (** Get the next event from an event reader.

     

       112
       112
       +
             Returns [None] when parsing is complete. *)

     

       113
       113
       +
       

     

       114
       114
       +
         val iter_events :

     

       115
       115
       +
           (event -> Yamlrw.Span.t -> unit) ->

     

       116
       116
       +
           _ Eio.Flow.source -> unit

     

       117
       117
       +
         (** Iterate over all events from a flow. *)

     

       118
       118
       +
       

     

       119
       119
       +
         val fold_events :

     

       120
       120
       +
           ('a -> event -> 'a) -> 'a ->

     

       121
       121
       +
           _ Eio.Flow.source -> 'a

     

       122
       122
       +
         (** Fold over all events from a flow. *)

     

       123
       123
       +
       

     

       124
       124
       +
         val iter_documents :

     

       125
       125
       +
           (document -> unit) ->

     

       126
       126
       +
           _ Eio.Flow.source -> unit

     

       127
       127
       +
         (** Iterate over documents from a flow, calling [f] for each document. *)

     

       128
       128
       +
       

     

       129
       129
       +
         val fold_documents :

     

       130
       130
       +
           ('a -> document -> 'a) -> 'a ->

     

       131
       131
       +
           _ Eio.Flow.source -> 'a

     

       132
       132
       +
         (** Fold over documents from a flow. *)

     

       133
       133
       +
       end

     

       134
       134
       +
       

     

       135
       135
       +
       (** {1 Writing to Eio Sinks} *)

     

       136
       136
       +
       

     

       137
       137
       +
       module Write : sig

     

       138
       138
       +
         (** Emit YAML to Eio flows.

     

       139
       139
       +
       

     

       140
       140
       +
             All functions write data directly to the underlying flow. *)

     

       141
       141
       +
       

     

       142
       142
       +
         (** {2 High-Level Emission} *)

     

       143
       143
       +
       

     

       144
       144
       +
         val value :

     

       145
       145
       +
           ?encoding:Yamlrw.Encoding.t ->

     

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

     

       147
       147
       +
           ?layout_style:Yamlrw.Layout_style.t ->

     

       148
       148
       +
           _ Eio.Flow.sink -> value -> unit

     

       149
       149
       +
         (** Write a JSON-compatible value to an Eio flow.

     

       150
       150
       +
       

     

       151
       151
       +
             @param encoding Output encoding (default: UTF-8)

     

       152
       152
       +
             @param scalar_style Preferred scalar style (default: Any)

     

       153
       153
       +
             @param layout_style Preferred layout style (default: Any) *)

     

       154
       154
       +
       

     

       155
       155
       +
         val yaml :

     

       156
       156
       +
           ?encoding:Yamlrw.Encoding.t ->

     

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

     

       158
       158
       +
           ?layout_style:Yamlrw.Layout_style.t ->

     

       159
       159
       +
           _ Eio.Flow.sink -> yaml -> unit

     

       160
       160
       +
         (** Write a full YAML value to an Eio flow.

     

       161
       161
       +
       

     

       162
       162
       +
             @param encoding Output encoding (default: UTF-8)

     

       163
       163
       +
             @param scalar_style Preferred scalar style (default: Any)

     

       164
       164
       +
             @param layout_style Preferred layout style (default: Any) *)

     

       165
       165
       +
       

     

       166
       166
       +
         val documents :

     

       167
       167
       +
           ?encoding:Yamlrw.Encoding.t ->

     

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

     

       169
       169
       +
           ?layout_style:Yamlrw.Layout_style.t ->

     

       170
       170
       +
           ?resolve_aliases:bool ->

     

       171
       171
       +
           _ Eio.Flow.sink -> document list -> unit

     

       172
       172
       +
         (** Write multiple YAML documents to an Eio flow.

     

       173
       173
       +
       

     

       174
       174
       +
             @param encoding Output encoding (default: UTF-8)

     

       175
       175
       +
             @param scalar_style Preferred scalar style (default: Any)

     

       176
       176
       +
             @param layout_style Preferred layout style (default: Any)

     

       177
       177
       +
             @param resolve_aliases Whether to expand aliases (default: true) *)

     

       178
       178
       +
       

     

       179
       179
       +
         (** {2 Event-Based Streaming} *)

     

       180
       180
       +
       

     

       181
       181
       +
         type event_writer

     

       182
       182
       +
         (** A streaming event writer backed by a flow.

     

       183
       183
       +
             Events are written incrementally to the underlying flow. *)

     

       184
       184
       +
       

     

       185
       185
       +
         val event_writer :

     

       186
       186
       +
           ?encoding:Yamlrw.Encoding.t ->

     

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

     

       188
       188
       +
           ?layout_style:Yamlrw.Layout_style.t ->

     

       189
       189
       +
           _ Eio.Flow.sink -> event_writer

     

       190
       190
       +
         (** Create an event writer that writes directly to a flow.

     

       191
       191
       +
             Events are written incrementally as they are emitted.

     

       192
       192
       +
       

     

       193
       193
       +
             @param encoding Output encoding (default: UTF-8)

     

       194
       194
       +
             @param scalar_style Preferred scalar style (default: Any)

     

       195
       195
       +
             @param layout_style Preferred layout style (default: Any) *)

     

       196
       196
       +
       

     

       197
       197
       +
         val emit : event_writer -> event -> unit

     

       198
       198
       +
         (** Emit a single event to the writer. *)

     

       199
       199
       +
       

     

       200
       200
       +
         val flush : event_writer -> unit

     

       201
       201
       +
         (** Flush the writer by sending end-of-data. *)

     

       202
       202
       +
       

     

       203
       203
       +
         val emit_all : _ Eio.Flow.sink -> event list -> unit

     

       204
       204
       +
         (** Emit events from a list to a flow. *)

     

       205
       205
       +
       end

     

       206
       206
       +
       

     

       207
       207
       +
       (** {1 Convenience Functions} *)

     

       208
       208
       +
       

     

       209
       209
       +
       val of_file :

     

       210
       210
       +
         ?resolve_aliases:bool ->

     

       211
       211
       +
         ?max_nodes:int ->

     

       212
       212
       +
         ?max_depth:int ->

     

       213
       213
       +
         fs:_ Eio.Path.t ->

     

       214
       214
       +
         string -> value

     

       215
       215
       +
       (** Read a value from a file path.

     

       216
       216
       +
       

     

       217
       217
       +
           @param fs The filesystem path (e.g., [Eio.Stdenv.fs env] or [Eio.Stdenv.cwd env]) *)

     

       218
       218
       +
       

     

       219
       219
       +
       val yaml_of_file :

     

       220
       220
       +
         ?resolve_aliases:bool ->

     

       221
       221
       +
         ?max_nodes:int ->

     

       222
       222
       +
         ?max_depth:int ->

     

       223
       223
       +
         fs:_ Eio.Path.t ->

     

       224
       224
       +
         string -> yaml

     

       225
       225
       +
       (** Read full YAML from a file path.

     

       226
       226
       +
       

     

       227
       227
       +
           @param fs The filesystem path (e.g., [Eio.Stdenv.fs env] or [Eio.Stdenv.cwd env]) *)

     

       228
       228
       +
       

     

       229
       229
       +
       val documents_of_file :

     

       230
       230
       +
         fs:_ Eio.Path.t ->

     

       231
       231
       +
         string -> document list

     

       232
       232
       +
       (** Read documents from a file path.

     

       233
       233
       +
       

     

       234
       234
       +
           @param fs The filesystem path (e.g., [Eio.Stdenv.fs env] or [Eio.Stdenv.cwd env]) *)

     

       235
       235
       +
       

     

       236
       236
       +
       val to_file :

     

       237
       237
       +
         ?encoding:Yamlrw.Encoding.t ->

     

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

     

       239
       239
       +
         ?layout_style:Yamlrw.Layout_style.t ->

     

       240
       240
       +
         fs:_ Eio.Path.t ->

     

       241
       241
       +
         string -> value -> unit

     

       242
       242
       +
       (** Write a value to a file path.

     

       243
       243
       +
       

     

       244
       244
       +
           @param fs The filesystem path (e.g., [Eio.Stdenv.fs env] or [Eio.Stdenv.cwd env]) *)

     

       245
       245
       +
       

     

       246
       246
       +
       val yaml_to_file :

     

       247
       247
       +
         ?encoding:Yamlrw.Encoding.t ->

     

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

     

       249
       249
       +
         ?layout_style:Yamlrw.Layout_style.t ->

     

       250
       250
       +
         fs:_ Eio.Path.t ->

     

       251
       251
       +
         string -> yaml -> unit

     

       252
       252
       +
       (** Write full YAML to a file path.

     

       253
       253
       +
       

     

       254
       254
       +
           @param fs The filesystem path (e.g., [Eio.Stdenv.fs env] or [Eio.Stdenv.cwd env]) *)

     

       255
       255
       +
       

     

       256
       256
       +
       val documents_to_file :

     

       257
       257
       +
         ?encoding:Yamlrw.Encoding.t ->

     

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

     

       259
       259
       +
         ?layout_style:Yamlrw.Layout_style.t ->

     

       260
       260
       +
         ?resolve_aliases:bool ->

     

       261
       261
       +
         fs:_ Eio.Path.t ->

     

       262
       262
       +
         string -> document list -> unit

     

       263
       263
       +
       (** Write documents to a file path.

     

       264
       264
       +
       

     

       265
       265
       +
           @param fs The filesystem path (e.g., [Eio.Stdenv.fs env] or [Eio.Stdenv.cwd env]) *)

+581

lib/emitter.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
       +
       (** Emitter - converts YAML data structures to string output

     

       7
       7
       +
       

     

       8
       8
       +
           The emitter can write to either a Buffer (default) or directly to a

     

       9
       9
       +
           bytesrw Bytes.Writer for streaming output. *)

     

       10
       10
       +
       

     

       11
       11
       +
       type config = {

     

       12
       12
       +
         encoding : Encoding.t;

     

       13
       13
       +
         scalar_style : Scalar_style.t;

     

       14
       14
       +
         layout_style : Layout_style.t;

     

       15
       15
       +
         indent : int;

     

       16
       16
       +
         width : int;

     

       17
       17
       +
         canonical : bool;

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       let default_config = {

     

       21
       21
       +
         encoding = `Utf8;

     

       22
       22
       +
         scalar_style = `Any;

     

       23
       23
       +
         layout_style = `Any;

     

       24
       24
       +
         indent = 2;

     

       25
       25
       +
         width = 80;

     

       26
       26
       +
         canonical = false;

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       type state =

     

       30
       30
       +
         | Initial

     

       31
       31
       +
         | Stream_started

     

       32
       32
       +
         | Document_started

     

       33
       33
       +
         | In_block_sequence of int  (* indent level *)

     

       34
       34
       +
         | In_block_mapping_key of int

     

       35
       35
       +
         | In_block_mapping_value of int

     

       36
       36
       +
         | In_block_mapping_first_key of int  (* first key after "- ", no indent needed *)

     

       37
       37
       +
         | In_flow_sequence

     

       38
       38
       +
         | In_flow_mapping_key

     

       39
       39
       +
         | In_flow_mapping_value

     

       40
       40
       +
         | Document_ended

     

       41
       41
       +
         | Stream_ended

     

       42
       42
       +
       

     

       43
       43
       +
       (** Output sink - either a Buffer or a bytesrw Writer *)

     

       44
       44
       +
       type sink =

     

       45
       45
       +
         | Buffer_sink of Buffer.t

     

       46
       46
       +
         | Writer_sink of Bytesrw.Bytes.Writer.t

     

       47
       47
       +
       

     

       48
       48
       +
       type t = {

     

       49
       49
       +
         config : config;

     

       50
       50
       +
         sink : sink;

     

       51
       51
       +
         mutable state : state;

     

       52
       52
       +
         mutable states : state list;

     

       53
       53
       +
         mutable indent : int;

     

       54
       54
       +
         mutable flow_level : int;

     

       55
       55
       +
         mutable need_separator : bool;

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       let create ?(config = default_config) () = {

     

       59
       59
       +
         config;

     

       60
       60
       +
         sink = Buffer_sink (Buffer.create 1024);

     

       61
       61
       +
         state = Initial;

     

       62
       62
       +
         states = [];

     

       63
       63
       +
         indent = 0;

     

       64
       64
       +
         flow_level = 0;

     

       65
       65
       +
         need_separator = false;

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       (** Create an emitter that writes directly to a Bytes.Writer *)

     

       69
       69
       +
       let of_writer ?(config = default_config) writer = {

     

       70
       70
       +
         config;

     

       71
       71
       +
         sink = Writer_sink writer;

     

       72
       72
       +
         state = Initial;

     

       73
       73
       +
         states = [];

     

       74
       74
       +
         indent = 0;

     

       75
       75
       +
         flow_level = 0;

     

       76
       76
       +
         need_separator = false;

     

       77
       77
       +
       }

     

       78
       78
       +
       

     

       79
       79
       +
       let contents t =

     

       80
       80
       +
         match t.sink with

     

       81
       81
       +
         | Buffer_sink buf -> Buffer.contents buf

     

       82
       82
       +
         | Writer_sink _ -> ""  (* No accumulated content for writer sink *)

     

       83
       83
       +
       

     

       84
       84
       +
       let reset t =

     

       85
       85
       +
         (match t.sink with

     

       86
       86
       +
          | Buffer_sink buf -> Buffer.clear buf

     

       87
       87
       +
          | Writer_sink _ -> ());

     

       88
       88
       +
         t.state <- Initial;

     

       89
       89
       +
         t.states <- [];

     

       90
       90
       +
         t.indent <- 0;

     

       91
       91
       +
         t.flow_level <- 0;

     

       92
       92
       +
         t.need_separator <- false

     

       93
       93
       +
       

     

       94
       94
       +
       (** Output helpers - write to appropriate sink *)

     

       95
       95
       +
       

     

       96
       96
       +
       let write t s =

     

       97
       97
       +
         match t.sink with

     

       98
       98
       +
         | Buffer_sink buf -> Buffer.add_string buf s

     

       99
       99
       +
         | Writer_sink w -> Bytesrw.Bytes.Writer.write_string w s

     

       100
       100
       +
       

     

       101
       101
       +
       let write_char t c =

     

       102
       102
       +
         match t.sink with

     

       103
       103
       +
         | Buffer_sink buf -> Buffer.add_char buf c

     

       104
       104
       +
         | Writer_sink w ->

     

       105
       105
       +
             let b = Bytes.make 1 c in

     

       106
       106
       +
             Bytesrw.Bytes.Writer.write_bytes w b

     

       107
       107
       +
       

     

       108
       108
       +
       let write_indent t =

     

       109
       109
       +
         if t.indent <= 8 then

     

       110
       110
       +
           for _ = 1 to t.indent do write_char t ' ' done

     

       111
       111
       +
         else

     

       112
       112
       +
           write t (String.make t.indent ' ')

     

       113
       113
       +
       

     

       114
       114
       +
       let write_newline t =

     

       115
       115
       +
         write_char t '\n'

     

       116
       116
       +
       

     

       117
       117
       +
       let push_state t s =

     

       118
       118
       +
         t.states <- t.state :: t.states;

     

       119
       119
       +
         t.state <- s

     

       120
       120
       +
       

     

       121
       121
       +
       let pop_state t =

     

       122
       122
       +
         match t.states with

     

       123
       123
       +
         | s :: rest ->

     

       124
       124
       +
             t.state <- s;

     

       125
       125
       +
             t.states <- rest

     

       126
       126
       +
         | [] ->

     

       127
       127
       +
             t.state <- Stream_ended

     

       128
       128
       +
       

     

       129
       129
       +
       (** Escape a string for double-quoted output.

     

       130
       130
       +
           Uses a buffer to batch writes instead of character-by-character. *)

     

       131
       131
       +
       let escape_double_quoted value =

     

       132
       132
       +
         let len = String.length value in

     

       133
       133
       +
         (* Check if any escaping is needed *)

     

       134
       134
       +
         let needs_escape = ref false in

     

       135
       135
       +
         for i = 0 to len - 1 do

     

       136
       136
       +
           match value.[i] with

     

       137
       137
       +
           | '"' | '\\' | '\n' | '\r' | '\t' -> needs_escape := true

     

       138
       138
       +
           | c when c < ' ' -> needs_escape := true

     

       139
       139
       +
           | _ -> ()

     

       140
       140
       +
         done;

     

       141
       141
       +
         if not !needs_escape then value

     

       142
       142
       +
         else begin

     

       143
       143
       +
           let buf = Buffer.create (len + len / 4) in

     

       144
       144
       +
           for i = 0 to len - 1 do

     

       145
       145
       +
             match value.[i] with

     

       146
       146
       +
             | '"' -> Buffer.add_string buf "\\\""

     

       147
       147
       +
             | '\\' -> Buffer.add_string buf "\\\\"

     

       148
       148
       +
             | '\n' -> Buffer.add_string buf "\\n"

     

       149
       149
       +
             | '\r' -> Buffer.add_string buf "\\r"

     

       150
       150
       +
             | '\t' -> Buffer.add_string buf "\\t"

     

       151
       151
       +
             | c when c < ' ' -> Buffer.add_string buf (Printf.sprintf "\\x%02x" (Char.code c))

     

       152
       152
       +
             | c -> Buffer.add_char buf c

     

       153
       153
       +
           done;

     

       154
       154
       +
           Buffer.contents buf

     

       155
       155
       +
         end

     

       156
       156
       +
       

     

       157
       157
       +
       (** Escape a string for single-quoted output. *)

     

       158
       158
       +
       let escape_single_quoted value =

     

       159
       159
       +
         if not (String.contains value '\'') then value

     

       160
       160
       +
         else begin

     

       161
       161
       +
           let len = String.length value in

     

       162
       162
       +
           let buf = Buffer.create (len + len / 8) in

     

       163
       163
       +
           for i = 0 to len - 1 do

     

       164
       164
       +
             let c = value.[i] in

     

       165
       165
       +
             if c = '\'' then Buffer.add_string buf "''"

     

       166
       166
       +
             else Buffer.add_char buf c

     

       167
       167
       +
           done;

     

       168
       168
       +
           Buffer.contents buf

     

       169
       169
       +
         end

     

       170
       170
       +
       

     

       171
       171
       +
       (** Write scalar with appropriate quoting *)

     

       172
       172
       +
       let write_scalar t ?(style = `Any) value =

     

       173
       173
       +
         match (match style with `Any -> Quoting.choose_style value | s -> s) with

     

       174
       174
       +
         | `Plain | `Any ->

     

       175
       175
       +
             write t value

     

       176
       176
       +
         | `Single_quoted ->

     

       177
       177
       +
             write_char t '\'';

     

       178
       178
       +
             write t (escape_single_quoted value);

     

       179
       179
       +
             write_char t '\''

     

       180
       180
       +
         | `Double_quoted ->

     

       181
       181
       +
             write_char t '"';

     

       182
       182
       +
             write t (escape_double_quoted value);

     

       183
       183
       +
             write_char t '"'

     

       184
       184
       +
         | `Literal ->

     

       185
       185
       +
             write t "|";

     

       186
       186
       +
             write_newline t;

     

       187
       187
       +
             String.split_on_char '\n' value |> List.iter (fun line ->

     

       188
       188
       +
               write_indent t;

     

       189
       189
       +
               write t line;

     

       190
       190
       +
               write_newline t

     

       191
       191
       +
             )

     

       192
       192
       +
         | `Folded ->

     

       193
       193
       +
             write t ">";

     

       194
       194
       +
             write_newline t;

     

       195
       195
       +
             String.split_on_char '\n' value |> List.iter (fun line ->

     

       196
       196
       +
               write_indent t;

     

       197
       197
       +
               write t line;

     

       198
       198
       +
               write_newline t

     

       199
       199
       +
             )

     

       200
       200
       +
       

     

       201
       201
       +
       (** Write anchor if present *)

     

       202
       202
       +
       let write_anchor t anchor =

     

       203
       203
       +
         match anchor with

     

       204
       204
       +
         | Some name ->

     

       205
       205
       +
             write_char t '&';

     

       206
       206
       +
             write t name;

     

       207
       207
       +
             write_char t ' '

     

       208
       208
       +
         | None -> ()

     

       209
       209
       +
       

     

       210
       210
       +
       (** Write tag if present and not implicit *)

     

       211
       211
       +
       let write_tag t ~implicit tag =

     

       212
       212
       +
         if not implicit then

     

       213
       213
       +
           match tag with

     

       214
       214
       +
           | Some tag_str ->

     

       215
       215
       +
               write_char t '!';

     

       216
       216
       +
               write t tag_str;

     

       217
       217
       +
               write_char t ' '

     

       218
       218
       +
           | None -> ()

     

       219
       219
       +
       

     

       220
       220
       +
       (** Emit events *)

     

       221
       221
       +
       

     

       222
       222
       +
       let emit t (ev : Event.t) =

     

       223
       223
       +
         match ev with

     

       224
       224
       +
         | Event.Stream_start _ ->

     

       225
       225
       +
             t.state <- Stream_started

     

       226
       226
       +
       

     

       227
       227
       +
         | Event.Stream_end ->

     

       228
       228
       +
             t.state <- Stream_ended

     

       229
       229
       +
       

     

       230
       230
       +
         | Event.Document_start { version; implicit } ->

     

       231
       231
       +
             if not implicit then begin

     

       232
       232
       +
               (match version with

     

       233
       233
       +
                | Some (maj, min) ->

     

       234
       234
       +
                    write t (Printf.sprintf "%%YAML %d.%d\n" maj min)

     

       235
       235
       +
                | None -> ());

     

       236
       236
       +
               write t "---";

     

       237
       237
       +
               write_newline t

     

       238
       238
       +
             end;

     

       239
       239
       +
             t.state <- Document_started

     

       240
       240
       +
       

     

       241
       241
       +
         | Event.Document_end { implicit } ->

     

       242
       242
       +
             if not implicit then begin

     

       243
       243
       +
               write t "...";

     

       244
       244
       +
               write_newline t

     

       245
       245
       +
             end;

     

       246
       246
       +
             t.state <- Document_ended

     

       247
       247
       +
       

     

       248
       248
       +
         | Event.Alias { anchor } ->

     

       249
       249
       +
             if t.flow_level > 0 then begin

     

       250
       250
       +
               if t.need_separator then write t ", ";

     

       251
       251
       +
               t.need_separator <- true;

     

       252
       252
       +
               write_char t '*';

     

       253
       253
       +
               write t anchor

     

       254
       254
       +
             end else begin

     

       255
       255
       +
               (match t.state with

     

       256
       256
       +
                | In_block_sequence _ ->

     

       257
       257
       +
                    write_indent t;

     

       258
       258
       +
                    write t "- *";

     

       259
       259
       +
                    write t anchor;

     

       260
       260
       +
                    write_newline t

     

       261
       261
       +
                | In_block_mapping_key _ ->

     

       262
       262
       +
                    write_indent t;

     

       263
       263
       +
                    write_char t '*';

     

       264
       264
       +
                    write t anchor;

     

       265
       265
       +
                    write t ": ";

     

       266
       266
       +
                    t.state <- In_block_mapping_value t.indent

     

       267
       267
       +
                | In_block_mapping_value indent ->

     

       268
       268
       +
                    write_char t '*';

     

       269
       269
       +
                    write t anchor;

     

       270
       270
       +
                    write_newline t;

     

       271
       271
       +
                    t.state <- In_block_mapping_key indent

     

       272
       272
       +
                | _ ->

     

       273
       273
       +
                    write_char t '*';

     

       274
       274
       +
                    write t anchor;

     

       275
       275
       +
                    write_newline t)

     

       276
       276
       +
             end

     

       277
       277
       +
       

     

       278
       278
       +
         | Event.Scalar { anchor; tag; value; plain_implicit; style; _ } ->

     

       279
       279
       +
             if t.flow_level > 0 then begin

     

       280
       280
       +
               (match t.state with

     

       281
       281
       +
                | In_flow_mapping_key ->

     

       282
       282
       +
                    if t.need_separator then write t ", ";

     

       283
       283
       +
                    write_anchor t anchor;

     

       284
       284
       +
                    write_tag t ~implicit:plain_implicit tag;

     

       285
       285
       +
                    write_scalar t ~style value;

     

       286
       286
       +
                    write t ": ";

     

       287
       287
       +
                    t.need_separator <- false;

     

       288
       288
       +
                    t.state <- In_flow_mapping_value

     

       289
       289
       +
                | In_flow_mapping_value ->

     

       290
       290
       +
                    write_anchor t anchor;

     

       291
       291
       +
                    write_tag t ~implicit:plain_implicit tag;

     

       292
       292
       +
                    write_scalar t ~style value;

     

       293
       293
       +
                    t.need_separator <- true;

     

       294
       294
       +
                    t.state <- In_flow_mapping_key

     

       295
       295
       +
                | _ ->

     

       296
       296
       +
                    if t.need_separator then write t ", ";

     

       297
       297
       +
                    t.need_separator <- true;

     

       298
       298
       +
                    write_anchor t anchor;

     

       299
       299
       +
                    write_tag t ~implicit:plain_implicit tag;

     

       300
       300
       +
                    write_scalar t ~style value)

     

       301
       301
       +
             end else begin

     

       302
       302
       +
               match t.state with

     

       303
       303
       +
               | In_block_sequence _ ->

     

       304
       304
       +
                   write_indent t;

     

       305
       305
       +
                   write t "- ";

     

       306
       306
       +
                   write_anchor t anchor;

     

       307
       307
       +
                   write_tag t ~implicit:plain_implicit tag;

     

       308
       308
       +
                   write_scalar t ~style value;

     

       309
       309
       +
                   write_newline t

     

       310
       310
       +
               | In_block_mapping_key indent ->

     

       311
       311
       +
                   write_indent t;

     

       312
       312
       +
                   write_anchor t anchor;

     

       313
       313
       +
                   write_tag t ~implicit:plain_implicit tag;

     

       314
       314
       +
                   write_scalar t ~style value;

     

       315
       315
       +
                   write_char t ':';

     

       316
       316
       +
                   t.state <- In_block_mapping_value indent

     

       317
       317
       +
               | In_block_mapping_first_key indent ->

     

       318
       318
       +
                   (* First key after "- ", no indent needed *)

     

       319
       319
       +
                   write_anchor t anchor;

     

       320
       320
       +
                   write_tag t ~implicit:plain_implicit tag;

     

       321
       321
       +
                   write_scalar t ~style value;

     

       322
       322
       +
                   write_char t ':';

     

       323
       323
       +
                   t.state <- In_block_mapping_value indent

     

       324
       324
       +
               | In_block_mapping_value indent ->

     

       325
       325
       +
                   write_char t ' ';

     

       326
       326
       +
                   write_anchor t anchor;

     

       327
       327
       +
                   write_tag t ~implicit:plain_implicit tag;

     

       328
       328
       +
                   write_scalar t ~style value;

     

       329
       329
       +
                   write_newline t;

     

       330
       330
       +
                   t.state <- In_block_mapping_key indent

     

       331
       331
       +
               | _ ->

     

       332
       332
       +
                   write_anchor t anchor;

     

       333
       333
       +
                   write_tag t ~implicit:plain_implicit tag;

     

       334
       334
       +
                   write_scalar t ~style value;

     

       335
       335
       +
                   write_newline t

     

       336
       336
       +
             end

     

       337
       337
       +
       

     

       338
       338
       +
         | Event.Sequence_start { anchor; tag; implicit; style } ->

     

       339
       339
       +
             let use_flow = style = `Flow || t.flow_level > 0 in

     

       340
       340
       +
             if t.flow_level > 0 then begin

     

       341
       341
       +
               (match t.state with

     

       342
       342
       +
                | In_flow_mapping_key ->

     

       343
       343
       +
                    if t.need_separator then write t ", ";

     

       344
       344
       +
                    write_anchor t anchor;

     

       345
       345
       +
                    write_tag t ~implicit tag;

     

       346
       346
       +
                    write_char t '[';

     

       347
       347
       +
                    t.flow_level <- t.flow_level + 1;

     

       348
       348
       +
                    t.need_separator <- false;

     

       349
       349
       +
                    push_state t In_flow_mapping_value;  (* After ] we'll be in value position but sequence handles it *)

     

       350
       350
       +
                    t.state <- In_flow_sequence

     

       351
       351
       +
                | In_flow_mapping_value ->

     

       352
       352
       +
                    write_anchor t anchor;

     

       353
       353
       +
                    write_tag t ~implicit tag;

     

       354
       354
       +
                    write_char t '[';

     

       355
       355
       +
                    t.flow_level <- t.flow_level + 1;

     

       356
       356
       +
                    t.need_separator <- false;

     

       357
       357
       +
                    push_state t In_flow_mapping_key;

     

       358
       358
       +
                    t.state <- In_flow_sequence

     

       359
       359
       +
                | _ ->

     

       360
       360
       +
                    if t.need_separator then write t ", ";

     

       361
       361
       +
                    write_anchor t anchor;

     

       362
       362
       +
                    write_tag t ~implicit tag;

     

       363
       363
       +
                    write_char t '[';

     

       364
       364
       +
                    t.flow_level <- t.flow_level + 1;

     

       365
       365
       +
                    t.need_separator <- false;

     

       366
       366
       +
                    push_state t In_flow_sequence)

     

       367
       367
       +
             end else begin

     

       368
       368
       +
               match t.state with

     

       369
       369
       +
               | In_block_sequence _ ->

     

       370
       370
       +
                   write_indent t;

     

       371
       371
       +
                   write t "- ";

     

       372
       372
       +
                   write_anchor t anchor;

     

       373
       373
       +
                   write_tag t ~implicit tag;

     

       374
       374
       +
                   if use_flow then begin

     

       375
       375
       +
                     write_char t '[';

     

       376
       376
       +
                     t.flow_level <- t.flow_level + 1;

     

       377
       377
       +
                     t.need_separator <- false;

     

       378
       378
       +
                     push_state t In_flow_sequence

     

       379
       379
       +
                   end else begin

     

       380
       380
       +
                     write_newline t;

     

       381
       381
       +
                     push_state t (In_block_sequence t.indent);

     

       382
       382
       +
                     t.indent <- t.indent + t.config.indent

     

       383
       383
       +
                   end

     

       384
       384
       +
               | In_block_mapping_key indent ->

     

       385
       385
       +
                   write_indent t;

     

       386
       386
       +
                   write_anchor t anchor;

     

       387
       387
       +
                   write_tag t ~implicit tag;

     

       388
       388
       +
                   write t ":";

     

       389
       389
       +
                   write_newline t;

     

       390
       390
       +
                   push_state t (In_block_mapping_key indent);

     

       391
       391
       +
                   t.indent <- t.indent + t.config.indent;

     

       392
       392
       +
                   t.state <- In_block_sequence t.indent

     

       393
       393
       +
               | In_block_mapping_first_key indent ->

     

       394
       394
       +
                   (* First key after "- " with sequence value - no indent *)

     

       395
       395
       +
                   write_anchor t anchor;

     

       396
       396
       +
                   write_tag t ~implicit tag;

     

       397
       397
       +
                   write t ":";

     

       398
       398
       +
                   write_newline t;

     

       399
       399
       +
                   push_state t (In_block_mapping_key indent);

     

       400
       400
       +
                   t.indent <- t.indent + t.config.indent;

     

       401
       401
       +
                   t.state <- In_block_sequence t.indent

     

       402
       402
       +
               | In_block_mapping_value indent ->

     

       403
       403
       +
                   write_anchor t anchor;

     

       404
       404
       +
                   write_tag t ~implicit tag;

     

       405
       405
       +
                   if use_flow then begin

     

       406
       406
       +
                     write_char t ' ';

     

       407
       407
       +
                     write_char t '[';

     

       408
       408
       +
                     t.flow_level <- t.flow_level + 1;

     

       409
       409
       +
                     t.need_separator <- false;

     

       410
       410
       +
                     (* Save key state to return to after flow sequence *)

     

       411
       411
       +
                     t.state <- In_block_mapping_key indent;

     

       412
       412
       +
                     push_state t In_flow_sequence

     

       413
       413
       +
                   end else begin

     

       414
       414
       +
                     write_newline t;

     

       415
       415
       +
                     (* Save key state to return to after nested sequence *)

     

       416
       416
       +
                     t.state <- In_block_mapping_key indent;

     

       417
       417
       +
                     push_state t (In_block_sequence (t.indent + t.config.indent));

     

       418
       418
       +
                     t.indent <- t.indent + t.config.indent

     

       419
       419
       +
                   end

     

       420
       420
       +
               | _ ->

     

       421
       421
       +
                   write_anchor t anchor;

     

       422
       422
       +
                   write_tag t ~implicit tag;

     

       423
       423
       +
                   if use_flow then begin

     

       424
       424
       +
                     write_char t '[';

     

       425
       425
       +
                     t.flow_level <- t.flow_level + 1;

     

       426
       426
       +
                     t.need_separator <- false;

     

       427
       427
       +
                     push_state t In_flow_sequence

     

       428
       428
       +
                   end else begin

     

       429
       429
       +
                     push_state t (In_block_sequence t.indent);

     

       430
       430
       +
                     t.state <- In_block_sequence t.indent

     

       431
       431
       +
                   end

     

       432
       432
       +
             end

     

       433
       433
       +
       

     

       434
       434
       +
         | Event.Sequence_end ->

     

       435
       435
       +
             if t.flow_level > 0 then begin

     

       436
       436
       +
               write_char t ']';

     

       437
       437
       +
               t.flow_level <- t.flow_level - 1;

     

       438
       438
       +
               t.need_separator <- true;

     

       439
       439
       +
               pop_state t;

     

       440
       440
       +
               (* Write newline if returning to block context *)

     

       441
       441
       +
               (match t.state with

     

       442
       442
       +
                | In_block_mapping_key _ | In_block_sequence _ -> write_newline t

     

       443
       443
       +
                | _ -> ())

     

       444
       444
       +
             end else begin

     

       445
       445
       +
               t.indent <- t.indent - t.config.indent;

     

       446
       446
       +
               pop_state t

     

       447
       447
       +
             end

     

       448
       448
       +
       

     

       449
       449
       +
         | Event.Mapping_start { anchor; tag; implicit; style } ->

     

       450
       450
       +
             let use_flow = style = `Flow || t.flow_level > 0 in

     

       451
       451
       +
             if t.flow_level > 0 then begin

     

       452
       452
       +
               (match t.state with

     

       453
       453
       +
                | In_flow_mapping_key ->

     

       454
       454
       +
                    if t.need_separator then write t ", ";

     

       455
       455
       +
                    write_anchor t anchor;

     

       456
       456
       +
                    write_tag t ~implicit tag;

     

       457
       457
       +
                    write_char t '{';

     

       458
       458
       +
                    t.flow_level <- t.flow_level + 1;

     

       459
       459
       +
                    t.need_separator <- false;

     

       460
       460
       +
                    push_state t In_flow_mapping_value;

     

       461
       461
       +
                    t.state <- In_flow_mapping_key

     

       462
       462
       +
                | In_flow_mapping_value ->

     

       463
       463
       +
                    write_anchor t anchor;

     

       464
       464
       +
                    write_tag t ~implicit tag;

     

       465
       465
       +
                    write_char t '{';

     

       466
       466
       +
                    t.flow_level <- t.flow_level + 1;

     

       467
       467
       +
                    t.need_separator <- false;

     

       468
       468
       +
                    push_state t In_flow_mapping_key;

     

       469
       469
       +
                    t.state <- In_flow_mapping_key

     

       470
       470
       +
                | _ ->

     

       471
       471
       +
                    if t.need_separator then write t ", ";

     

       472
       472
       +
                    write_anchor t anchor;

     

       473
       473
       +
                    write_tag t ~implicit tag;

     

       474
       474
       +
                    write_char t '{';

     

       475
       475
       +
                    t.flow_level <- t.flow_level + 1;

     

       476
       476
       +
                    t.need_separator <- false;

     

       477
       477
       +
                    push_state t In_flow_mapping_key)

     

       478
       478
       +
             end else begin

     

       479
       479
       +
               match t.state with

     

       480
       480
       +
               | In_block_sequence _ ->

     

       481
       481
       +
                   write_indent t;

     

       482
       482
       +
                   write t "- ";

     

       483
       483
       +
                   write_anchor t anchor;

     

       484
       484
       +
                   write_tag t ~implicit tag;

     

       485
       485
       +
                   if use_flow then begin

     

       486
       486
       +
                     write_char t '{';

     

       487
       487
       +
                     t.flow_level <- t.flow_level + 1;

     

       488
       488
       +
                     t.need_separator <- false;

     

       489
       489
       +
                     push_state t In_flow_mapping_key

     

       490
       490
       +
                   end else begin

     

       491
       491
       +
                     (* Don't write newline - first key goes on same line as "- " *)

     

       492
       492
       +
                     push_state t (In_block_sequence t.indent);

     

       493
       493
       +
                     t.indent <- t.indent + t.config.indent;

     

       494
       494
       +
                     t.state <- In_block_mapping_first_key t.indent

     

       495
       495
       +
                   end

     

       496
       496
       +
               | In_block_mapping_key indent ->

     

       497
       497
       +
                   write_indent t;

     

       498
       498
       +
                   write_anchor t anchor;

     

       499
       499
       +
                   write_tag t ~implicit tag;

     

       500
       500
       +
                   write t ":";

     

       501
       501
       +
                   write_newline t;

     

       502
       502
       +
                   push_state t (In_block_mapping_key indent);

     

       503
       503
       +
                   t.indent <- t.indent + t.config.indent;

     

       504
       504
       +
                   t.state <- In_block_mapping_key t.indent

     

       505
       505
       +
               | In_block_mapping_first_key indent ->

     

       506
       506
       +
                   (* First key after "- " with mapping value - no indent *)

     

       507
       507
       +
                   write_anchor t anchor;

     

       508
       508
       +
                   write_tag t ~implicit tag;

     

       509
       509
       +
                   write t ":";

     

       510
       510
       +
                   write_newline t;

     

       511
       511
       +
                   push_state t (In_block_mapping_key indent);

     

       512
       512
       +
                   t.indent <- t.indent + t.config.indent;

     

       513
       513
       +
                   t.state <- In_block_mapping_key t.indent

     

       514
       514
       +
               | In_block_mapping_value indent ->

     

       515
       515
       +
                   write_anchor t anchor;

     

       516
       516
       +
                   write_tag t ~implicit tag;

     

       517
       517
       +
                   if use_flow then begin

     

       518
       518
       +
                     write_char t ' ';

     

       519
       519
       +
                     write_char t '{';

     

       520
       520
       +
                     t.flow_level <- t.flow_level + 1;

     

       521
       521
       +
                     t.need_separator <- false;

     

       522
       522
       +
                     (* Save key state to return to after flow mapping *)

     

       523
       523
       +
                     t.state <- In_block_mapping_key indent;

     

       524
       524
       +
                     push_state t In_flow_mapping_key

     

       525
       525
       +
                   end else begin

     

       526
       526
       +
                     write_newline t;

     

       527
       527
       +
                     (* Save key state to return to after nested mapping *)

     

       528
       528
       +
                     t.state <- In_block_mapping_key indent;

     

       529
       529
       +
                     push_state t (In_block_mapping_key (t.indent + t.config.indent));

     

       530
       530
       +
                     t.indent <- t.indent + t.config.indent

     

       531
       531
       +
                   end

     

       532
       532
       +
               | _ ->

     

       533
       533
       +
                   write_anchor t anchor;

     

       534
       534
       +
                   write_tag t ~implicit tag;

     

       535
       535
       +
                   if use_flow then begin

     

       536
       536
       +
                     write_char t '{';

     

       537
       537
       +
                     t.flow_level <- t.flow_level + 1;

     

       538
       538
       +
                     t.need_separator <- false;

     

       539
       539
       +
                     push_state t In_flow_mapping_key

     

       540
       540
       +
                   end else begin

     

       541
       541
       +
                     push_state t (In_block_mapping_key t.indent);

     

       542
       542
       +
                     t.state <- In_block_mapping_key t.indent

     

       543
       543
       +
                   end

     

       544
       544
       +
             end

     

       545
       545
       +
       

     

       546
       546
       +
         | Event.Mapping_end ->

     

       547
       547
       +
             if t.flow_level > 0 then begin

     

       548
       548
       +
               write_char t '}';

     

       549
       549
       +
               t.flow_level <- t.flow_level - 1;

     

       550
       550
       +
               t.need_separator <- true;

     

       551
       551
       +
               pop_state t;

     

       552
       552
       +
               (* Write newline if returning to block context *)

     

       553
       553
       +
               (match t.state with

     

       554
       554
       +
                | In_block_mapping_key _ | In_block_sequence _ -> write_newline t

     

       555
       555
       +
                | _ -> ())

     

       556
       556
       +
             end else begin

     

       557
       557
       +
               t.indent <- t.indent - t.config.indent;

     

       558
       558
       +
               pop_state t

     

       559
       559
       +
             end

     

       560
       560
       +
       

     

       561
       561
       +
       (** Access to the underlying buffer for advanced use.

     

       562
       562
       +
           Returns None if emitter is writing to a Writer instead of Buffer. *)

     

       563
       563
       +
       let buffer t =

     

       564
       564
       +
         match t.sink with

     

       565
       565
       +
         | Buffer_sink buf -> Some buf

     

       566
       566
       +
         | Writer_sink _ -> None

     

       567
       567
       +
       

     

       568
       568
       +
       (** Get config *)

     

       569
       569
       +
       let config t = t.config

     

       570
       570
       +
       

     

       571
       571
       +
       (** Check if emitter is writing to a Writer *)

     

       572
       572
       +
       let is_streaming t =

     

       573
       573
       +
         match t.sink with

     

       574
       574
       +
         | Writer_sink _ -> true

     

       575
       575
       +
         | Buffer_sink _ -> false

     

       576
       576
       +
       

     

       577
       577
       +
       (** Flush the writer sink (no-op for buffer sink) *)

     

       578
       578
       +
       let flush t =

     

       579
       579
       +
         match t.sink with

     

       580
       580
       +
         | Writer_sink w -> Bytesrw.Bytes.Writer.write_eod w

     

       581
       581
       +
         | Buffer_sink _ -> ()

+50

lib/encoding.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
       +
       (** Character encoding detection and handling *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t = [

     

       9
       9
       +
         | `Utf8

     

       10
       10
       +
         | `Utf16be

     

       11
       11
       +
         | `Utf16le

     

       12
       12
       +
         | `Utf32be

     

       13
       13
       +
         | `Utf32le

     

       14
       14
       +
       ]

     

       15
       15
       +
       

     

       16
       16
       +
       let to_string = function

     

       17
       17
       +
         | `Utf8 -> "UTF-8"

     

       18
       18
       +
         | `Utf16be -> "UTF-16BE"

     

       19
       19
       +
         | `Utf16le -> "UTF-16LE"

     

       20
       20
       +
         | `Utf32be -> "UTF-32BE"

     

       21
       21
       +
         | `Utf32le -> "UTF-32LE"

     

       22
       22
       +
       

     

       23
       23
       +
       let pp fmt t =

     

       24
       24
       +
         Format.pp_print_string fmt (to_string t)

     

       25
       25
       +
       

     

       26
       26
       +
       (** Detect encoding from BOM or first bytes.

     

       27
       27
       +
           Returns (encoding, bom_length) *)

     

       28
       28
       +
       let detect s =

     

       29
       29
       +
         let len = String.length s in

     

       30
       30
       +
         if len = 0 then (`Utf8, 0)

     

       31
       31
       +
         else

     

       32
       32
       +
           let b0 = Char.code s.[0] in

     

       33
       33
       +
           let b1 = if len > 1 then Char.code s.[1] else 0 in

     

       34
       34
       +
           let b2 = if len > 2 then Char.code s.[2] else 0 in

     

       35
       35
       +
           let b3 = if len > 3 then Char.code s.[3] else 0 in

     

       36
       36
       +
           match (b0, b1, b2, b3) with

     

       37
       37
       +
           (* BOM patterns *)

     

       38
       38
       +
           | (0xEF, 0xBB, 0xBF, _) -> (`Utf8, 3)

     

       39
       39
       +
           | (0xFE, 0xFF, _, _) -> (`Utf16be, 2)

     

       40
       40
       +
           | (0xFF, 0xFE, 0x00, 0x00) -> (`Utf32le, 4)

     

       41
       41
       +
           | (0xFF, 0xFE, _, _) -> (`Utf16le, 2)

     

       42
       42
       +
           | (0x00, 0x00, 0xFE, 0xFF) -> (`Utf32be, 4)

     

       43
       43
       +
           (* Content pattern detection (no BOM) *)

     

       44
       44
       +
           | (0x00, 0x00, 0x00, b3) when b3 <> 0x00 -> (`Utf32be, 0)

     

       45
       45
       +
           | (b0, 0x00, 0x00, 0x00) when b0 <> 0x00 -> (`Utf32le, 0)

     

       46
       46
       +
           | (0x00, b1, _, _) when b1 <> 0x00 -> (`Utf16be, 0)

     

       47
       47
       +
           | (b0, 0x00, _, _) when b0 <> 0x00 -> (`Utf16le, 0)

     

       48
       48
       +
           | _ -> (`Utf8, 0)

     

       49
       49
       +
       

     

       50
       50
       +
       let equal a b = a = b

+372

lib/error.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
       +
       (** {1 Error Handling}

     

       7
       7
       +
       

     

       8
       8
       +
           Comprehensive error reporting for YAML parsing and emission.

     

       9
       9
       +
       

     

       10
       10
       +
           This module provides detailed error types that correspond to various

     

       11
       11
       +
           failure modes in YAML processing, as specified in the

     

       12
       12
       +
           {{:https://yaml.org/spec/1.2.2/}YAML 1.2.2 specification}.

     

       13
       13
       +
       

     

       14
       14
       +
           Each error includes:

     

       15
       15
       +
           - A classification of the error type ({!type:kind})

     

       16
       16
       +
           - Optional source location information ({!type:Span.t})

     

       17
       17
       +
           - A context stack showing where the error occurred

     

       18
       18
       +
           - Optional source text for error display

     

       19
       19
       +
       

     

       20
       20
       +
           See also {{:https://yaml.org/spec/1.2.2/#31-processes}Section 3.1 (Processes)}

     

       21
       21
       +
           for background on the YAML processing model. *)

     

       22
       22
       +
       

     

       23
       23
       +
       (** {2 Error Classification}

     

       24
       24
       +
       

     

       25
       25
       +
           Error kinds are organized by the processing stage where they occur:

     

       26
       26
       +
           - Scanner errors: Lexical analysis failures (character-level)

     

       27
       27
       +
           - Parser errors: Syntax errors in event stream

     

       28
       28
       +
           - Loader errors: Semantic errors during representation construction

     

       29
       29
       +
           - Emitter errors: Failures during YAML generation *)

     

       30
       30
       +
       type kind =

     

       31
       31
       +
         (* Scanner errors - see {{:https://yaml.org/spec/1.2.2/#51-character-set}Section 5.1} *)

     

       32
       32
       +
         | Unexpected_character of char

     

       33
       33
       +
             (** Invalid character in input. See

     

       34
       34
       +
                 {{:https://yaml.org/spec/1.2.2/#51-character-set}Section 5.1 (Character Set)}. *)

     

       35
       35
       +
         | Unexpected_eof

     

       36
       36
       +
             (** Premature end of input. *)

     

       37
       37
       +
         | Invalid_escape_sequence of string

     

       38
       38
       +
             (** Invalid escape in double-quoted string. See

     

       39
       39
       +
                 {{:https://yaml.org/spec/1.2.2/#57-escaped-characters}Section 5.7 (Escaped Characters)}. *)

     

       40
       40
       +
         | Invalid_unicode_escape of string

     

       41
       41
       +
             (** Invalid Unicode escape sequence (\uXXXX or \UXXXXXXXX). *)

     

       42
       42
       +
         | Invalid_hex_escape of string

     

       43
       43
       +
             (** Invalid hexadecimal escape sequence (\xXX). *)

     

       44
       44
       +
         | Invalid_tag of string

     

       45
       45
       +
             (** Malformed tag syntax. See

     

       46
       46
       +
                 {{:https://yaml.org/spec/1.2.2/#681-node-tags}Section 6.8.1 (Node Tags)}. *)

     

       47
       47
       +
         | Invalid_anchor of string

     

       48
       48
       +
             (** Malformed anchor name. See

     

       49
       49
       +
                 {{:https://yaml.org/spec/1.2.2/#3222-anchors-and-aliases}Section 3.2.2.2 (Anchors and Aliases)}. *)

     

       50
       50
       +
         | Invalid_alias of string

     

       51
       51
       +
             (** Malformed alias reference. See

     

       52
       52
       +
                 {{:https://yaml.org/spec/1.2.2/#3222-anchors-and-aliases}Section 3.2.2.2 (Anchors and Aliases)}. *)

     

       53
       53
       +
         | Invalid_comment

     

       54
       54
       +
             (** Comment not properly separated from content. See

     

       55
       55
       +
                 {{:https://yaml.org/spec/1.2.2/#62-comments}Section 6.2 (Comments)}. *)

     

       56
       56
       +
         | Unclosed_single_quote

     

       57
       57
       +
             (** Unterminated single-quoted scalar. See

     

       58
       58
       +
                 {{:https://yaml.org/spec/1.2.2/#72-single-quoted-style}Section 7.2 (Single-Quoted Style)}. *)

     

       59
       59
       +
         | Unclosed_double_quote

     

       60
       60
       +
             (** Unterminated double-quoted scalar. See

     

       61
       61
       +
                 {{:https://yaml.org/spec/1.2.2/#73-double-quoted-style}Section 7.3 (Double-Quoted Style)}. *)

     

       62
       62
       +
         | Unclosed_flow_sequence

     

       63
       63
       +
             (** Missing closing bracket \] for flow sequence. See

     

       64
       64
       +
                 {{:https://yaml.org/spec/1.2.2/#742-flow-sequences}Section 7.4.2 (Flow Sequences)}. *)

     

       65
       65
       +
         | Unclosed_flow_mapping

     

       66
       66
       +
             (** Missing closing brace \} for flow mapping. See

     

       67
       67
       +
                 {{:https://yaml.org/spec/1.2.2/#743-flow-mappings}Section 7.4.3 (Flow Mappings)}. *)

     

       68
       68
       +
         | Invalid_indentation of int * int

     

       69
       69
       +
             (** Incorrect indentation level (expected, got). See

     

       70
       70
       +
                 {{:https://yaml.org/spec/1.2.2/#61-indentation-spaces}Section 6.1 (Indentation Spaces)}. *)

     

       71
       71
       +
         | Invalid_flow_indentation

     

       72
       72
       +
             (** Content in flow collection must be indented. See

     

       73
       73
       +
                 {{:https://yaml.org/spec/1.2.2/#74-flow-styles}Section 7.4 (Flow Styles)}. *)

     

       74
       74
       +
         | Tab_in_indentation

     

       75
       75
       +
             (** Tab character used for indentation (only spaces allowed). See

     

       76
       76
       +
                 {{:https://yaml.org/spec/1.2.2/#61-indentation-spaces}Section 6.1 (Indentation Spaces)}. *)

     

       77
       77
       +
         | Invalid_block_scalar_header of string

     

       78
       78
       +
             (** Malformed block scalar header (| or >). See

     

       79
       79
       +
                 {{:https://yaml.org/spec/1.2.2/#81-block-scalar-styles}Section 8.1 (Block Scalar Styles)}. *)

     

       80
       80
       +
         | Invalid_quoted_scalar_indentation of string

     

       81
       81
       +
             (** Incorrect indentation in quoted scalar. *)

     

       82
       82
       +
         | Invalid_directive of string

     

       83
       83
       +
             (** Malformed directive. See

     

       84
       84
       +
                 {{:https://yaml.org/spec/1.2.2/#68-directives}Section 6.8 (Directives)}. *)

     

       85
       85
       +
         | Invalid_yaml_version of string

     

       86
       86
       +
             (** Unsupported YAML version in %YAML directive. See

     

       87
       87
       +
                 {{:https://yaml.org/spec/1.2.2/#681-yaml-directives}Section 6.8.1 (YAML Directives)}. *)

     

       88
       88
       +
         | Invalid_tag_directive of string

     

       89
       89
       +
             (** Malformed %TAG directive. See

     

       90
       90
       +
                 {{:https://yaml.org/spec/1.2.2/#682-tag-directives}Section 6.8.2 (TAG Directives)}. *)

     

       91
       91
       +
         | Reserved_directive of string

     

       92
       92
       +
             (** Reserved directive name. See

     

       93
       93
       +
                 {{:https://yaml.org/spec/1.2.2/#683-reserved-directives}Section 6.8.3 (Reserved Directives)}. *)

     

       94
       94
       +
         | Illegal_flow_key_line

     

       95
       95
       +
             (** Key and colon must be on same line in flow context. See

     

       96
       96
       +
                 {{:https://yaml.org/spec/1.2.2/#743-flow-mappings}Section 7.4.3 (Flow Mappings)}. *)

     

       97
       97
       +
         | Block_sequence_disallowed

     

       98
       98
       +
             (** Block sequence entries not allowed in this context. See

     

       99
       99
       +
                 {{:https://yaml.org/spec/1.2.2/#82-block-collection-styles}Section 8.2 (Block Collection Styles)}. *)

     

       100
       100
       +
       

     

       101
       101
       +
         (* Parser errors - see {{:https://yaml.org/spec/1.2.2/#3-processing-yaml-information}Section 3 (Processing)} *)

     

       102
       102
       +
         | Unexpected_token of string

     

       103
       103
       +
             (** Unexpected token in event stream. *)

     

       104
       104
       +
         | Expected_document_start

     

       105
       105
       +
             (** Expected document start marker (---). See

     

       106
       106
       +
                 {{:https://yaml.org/spec/1.2.2/#912-document-markers}Section 9.1.2 (Document Markers)}. *)

     

       107
       107
       +
         | Expected_document_end

     

       108
       108
       +
             (** Expected document end marker (...). See

     

       109
       109
       +
                 {{:https://yaml.org/spec/1.2.2/#912-document-markers}Section 9.1.2 (Document Markers)}. *)

     

       110
       110
       +
         | Expected_block_entry

     

       111
       111
       +
             (** Expected block sequence entry marker (-). See

     

       112
       112
       +
                 {{:https://yaml.org/spec/1.2.2/#821-block-sequences}Section 8.2.1 (Block Sequences)}. *)

     

       113
       113
       +
         | Expected_key

     

       114
       114
       +
             (** Expected mapping key. See

     

       115
       115
       +
                 {{:https://yaml.org/spec/1.2.2/#822-block-mappings}Section 8.2.2 (Block Mappings)}. *)

     

       116
       116
       +
         | Expected_value

     

       117
       117
       +
             (** Expected mapping value after colon. See

     

       118
       118
       +
                 {{:https://yaml.org/spec/1.2.2/#822-block-mappings}Section 8.2.2 (Block Mappings)}. *)

     

       119
       119
       +
         | Expected_node

     

       120
       120
       +
             (** Expected a YAML node. *)

     

       121
       121
       +
         | Expected_scalar

     

       122
       122
       +
             (** Expected a scalar value. *)

     

       123
       123
       +
         | Expected_sequence_end

     

       124
       124
       +
             (** Expected closing bracket \] for flow sequence. See

     

       125
       125
       +
                 {{:https://yaml.org/spec/1.2.2/#742-flow-sequences}Section 7.4.2 (Flow Sequences)}. *)

     

       126
       126
       +
         | Expected_mapping_end

     

       127
       127
       +
             (** Expected closing brace \} for flow mapping. See

     

       128
       128
       +
                 {{:https://yaml.org/spec/1.2.2/#743-flow-mappings}Section 7.4.3 (Flow Mappings)}. *)

     

       129
       129
       +
         | Duplicate_anchor of string

     

       130
       130
       +
             (** Anchor name defined multiple times. See

     

       131
       131
       +
                 {{:https://yaml.org/spec/1.2.2/#3222-anchors-and-aliases}Section 3.2.2.2 (Anchors and Aliases)}. *)

     

       132
       132
       +
         | Undefined_alias of string

     

       133
       133
       +
             (** Alias references non-existent anchor. See

     

       134
       134
       +
                 {{:https://yaml.org/spec/1.2.2/#3222-anchors-and-aliases}Section 3.2.2.2 (Anchors and Aliases)}. *)

     

       135
       135
       +
         | Alias_cycle of string

     

       136
       136
       +
             (** Circular reference in alias chain. See

     

       137
       137
       +
                 {{:https://yaml.org/spec/1.2.2/#3222-anchors-and-aliases}Section 3.2.2.2 (Anchors and Aliases)}. *)

     

       138
       138
       +
         | Multiple_documents

     

       139
       139
       +
             (** Multiple documents found when single document expected. See

     

       140
       140
       +
                 {{:https://yaml.org/spec/1.2.2/#912-document-markers}Section 9.1.2 (Document Markers)}. *)

     

       141
       141
       +
         | Mapping_key_too_long

     

       142
       142
       +
             (** Mapping key exceeds maximum length (1024 characters). *)

     

       143
       143
       +
       

     

       144
       144
       +
         (* Loader errors - see {{:https://yaml.org/spec/1.2.2/#31-processes}Section 3.1 (Processes)} *)

     

       145
       145
       +
         | Invalid_scalar_conversion of string * string

     

       146
       146
       +
             (** Cannot convert scalar value to target type (value, target type).

     

       147
       147
       +
                 See {{:https://yaml.org/spec/1.2.2/#103-core-schema}Section 10.3 (Core Schema)}. *)

     

       148
       148
       +
         | Type_mismatch of string * string

     

       149
       149
       +
             (** Value has wrong type for operation (expected, got). *)

     

       150
       150
       +
         | Unresolved_alias of string

     

       151
       151
       +
             (** Alias encountered during conversion but not resolved.

     

       152
       152
       +
                 See {{:https://yaml.org/spec/1.2.2/#3222-anchors-and-aliases}Section 3.2.2.2 (Anchors and Aliases)}. *)

     

       153
       153
       +
         | Key_not_found of string

     

       154
       154
       +
             (** Mapping key not found. *)

     

       155
       155
       +
         | Alias_expansion_node_limit of int

     

       156
       156
       +
             (** Alias expansion exceeded maximum node count (protection against billion laughs attack).

     

       157
       157
       +
                 See {{:https://yaml.org/spec/1.2.2/#321-processes}Section 3.2.1 (Processes)}.

     

       158
       158
       +
       

     

       159
       159
       +
                 The "billion laughs attack" (also known as an XML bomb) is a denial-of-service

     

       160
       160
       +
                 attack where a small YAML document expands to enormous size through recursive

     

       161
       161
       +
                 alias expansion. This limit prevents such attacks. *)

     

       162
       162
       +
         | Alias_expansion_depth_limit of int

     

       163
       163
       +
             (** Alias expansion exceeded maximum nesting depth (protection against deeply nested aliases).

     

       164
       164
       +
                 See {{:https://yaml.org/spec/1.2.2/#321-processes}Section 3.2.1 (Processes)}. *)

     

       165
       165
       +
       

     

       166
       166
       +
         (* Emitter errors *)

     

       167
       167
       +
         | Invalid_encoding of string

     

       168
       168
       +
             (** Invalid character encoding specified. See

     

       169
       169
       +
                 {{:https://yaml.org/spec/1.2.2/#51-character-set}Section 5.1 (Character Set)}. *)

     

       170
       170
       +
         | Scalar_contains_invalid_chars of string

     

       171
       171
       +
             (** Scalar contains characters invalid for chosen style. *)

     

       172
       172
       +
         | Anchor_not_set

     

       173
       173
       +
             (** Attempted to emit alias before anchor was defined. *)

     

       174
       174
       +
         | Invalid_state of string

     

       175
       175
       +
             (** Emitter in invalid state for requested operation. *)

     

       176
       176
       +
       

     

       177
       177
       +
         (* Generic *)

     

       178
       178
       +
         | Custom of string

     

       179
       179
       +
             (** Custom error message. *)

     

       180
       180
       +
       

     

       181
       181
       +
       (** {2 Error Value}

     

       182
       182
       +
       

     

       183
       183
       +
           Full error information including classification, location, and context. *)

     

       184
       184
       +
       type t = {

     

       185
       185
       +
         kind : kind;

     

       186
       186
       +
             (** The specific error classification. *)

     

       187
       187
       +
         span : Span.t option;

     

       188
       188
       +
             (** Source location where the error occurred (if available). *)

     

       189
       189
       +
         context : string list;

     

       190
       190
       +
             (** Context stack showing the processing path leading to the error. *)

     

       191
       191
       +
         source : string option;

     

       192
       192
       +
             (** Source text for displaying the error in context. *)

     

       193
       193
       +
       }

     

       194
       194
       +
       

     

       195
       195
       +
       (** {2 Exception}

     

       196
       196
       +
       

     

       197
       197
       +
           The main exception type raised by all yamlrw operations.

     

       198
       198
       +
       

     

       199
       199
       +
           All parsing, loading, and emitting errors are reported by raising

     

       200
       200
       +
           this exception with detailed error information. *)

     

       201
       201
       +
       exception Yamlrw_error of t

     

       202
       202
       +
       

     

       203
       203
       +
       let () =

     

       204
       204
       +
         Printexc.register_printer (function

     

       205
       205
       +
           | Yamlrw_error e ->

     

       206
       206
       +
               let loc = match e.span with

     

       207
       207
       +
                 | None -> ""

     

       208
       208
       +
                 | Some span -> " at " ^ Span.to_string span

     

       209
       209
       +
               in

     

       210
       210
       +
               Some (Printf.sprintf "Yamlrw_error: %s%s"

     

       211
       211
       +
                 (match e.kind with Custom s -> s | _ -> "error") loc)

     

       212
       212
       +
           | _ -> None)

     

       213
       213
       +
       

     

       214
       214
       +
       (** {2 Error Construction} *)

     

       215
       215
       +
       

     

       216
       216
       +
       (** [make ?span ?context ?source kind] constructs an error value.

     

       217
       217
       +
       

     

       218
       218
       +
           @param span Source location

     

       219
       219
       +
           @param context Context stack (defaults to empty)

     

       220
       220
       +
           @param source Source text

     

       221
       221
       +
           @param kind Error classification *)

     

       222
       222
       +
       let make ?span ?(context=[]) ?source kind =

     

       223
       223
       +
         { kind; span; context; source }

     

       224
       224
       +
       

     

       225
       225
       +
       (** [raise ?span ?context ?source kind] constructs and raises an error.

     

       226
       226
       +
       

     

       227
       227
       +
           This is the primary way to report errors in yamlrw.

     

       228
       228
       +
       

     

       229
       229
       +
           @param span Source location

     

       230
       230
       +
           @param context Context stack

     

       231
       231
       +
           @param source Source text

     

       232
       232
       +
           @param kind Error classification

     

       233
       233
       +
           @raise Yamlrw_error *)

     

       234
       234
       +
       let raise ?span ?context ?source kind =

     

       235
       235
       +
         Stdlib.raise (Yamlrw_error (make ?span ?context ?source kind))

     

       236
       236
       +
       

     

       237
       237
       +
       (** [raise_at pos kind] raises an error at a specific position.

     

       238
       238
       +
       

     

       239
       239
       +
           @param pos Source position

     

       240
       240
       +
           @param kind Error classification

     

       241
       241
       +
           @raise Yamlrw_error *)

     

       242
       242
       +
       let raise_at pos kind =

     

       243
       243
       +
         let span = Span.point pos in

     

       244
       244
       +
         raise ~span kind

     

       245
       245
       +
       

     

       246
       246
       +
       (** [raise_span span kind] raises an error at a specific span.

     

       247
       247
       +
       

     

       248
       248
       +
           @param span Source span

     

       249
       249
       +
           @param kind Error classification

     

       250
       250
       +
           @raise Yamlrw_error *)

     

       251
       251
       +
       let raise_span span kind =

     

       252
       252
       +
         raise ~span kind

     

       253
       253
       +
       

     

       254
       254
       +
       (** [with_context ctx f] executes [f ()] and adds [ctx] to any raised error's context.

     

       255
       255
       +
       

     

       256
       256
       +
           This is useful for tracking the processing path through nested structures.

     

       257
       257
       +
       

     

       258
       258
       +
           @param ctx Context description (e.g., "parsing mapping key")

     

       259
       259
       +
           @param f Function to execute *)

     

       260
       260
       +
       let with_context ctx f =

     

       261
       261
       +
         try f () with

     

       262
       262
       +
         | Yamlrw_error e ->

     

       263
       263
       +
             Stdlib.raise (Yamlrw_error { e with context = ctx :: e.context })

     

       264
       264
       +
       

     

       265
       265
       +
       (** {2 Error Formatting} *)

     

       266
       266
       +
       

     

       267
       267
       +
       (** [kind_to_string kind] converts an error kind to a human-readable string. *)

     

       268
       268
       +
       let kind_to_string = function

     

       269
       269
       +
         | Unexpected_character c -> Printf.sprintf "unexpected character %C" c

     

       270
       270
       +
         | Unexpected_eof -> "unexpected end of input"

     

       271
       271
       +
         | Invalid_escape_sequence s -> Printf.sprintf "invalid escape sequence: %s" s

     

       272
       272
       +
         | Invalid_unicode_escape s -> Printf.sprintf "invalid unicode escape: %s" s

     

       273
       273
       +
         | Invalid_hex_escape s -> Printf.sprintf "invalid hex escape: %s" s

     

       274
       274
       +
         | Invalid_tag s -> Printf.sprintf "invalid tag: %s" s

     

       275
       275
       +
         | Invalid_anchor s -> Printf.sprintf "invalid anchor: %s" s

     

       276
       276
       +
         | Invalid_alias s -> Printf.sprintf "invalid alias: %s" s

     

       277
       277
       +
         | Invalid_comment -> "comments must be separated from other tokens by whitespace"

     

       278
       278
       +
         | Unclosed_single_quote -> "unclosed single quote"

     

       279
       279
       +
         | Unclosed_double_quote -> "unclosed double quote"

     

       280
       280
       +
         | Unclosed_flow_sequence -> "unclosed flow sequence '['"

     

       281
       281
       +
         | Unclosed_flow_mapping -> "unclosed flow mapping '{'"

     

       282
       282
       +
         | Invalid_indentation (expected, got) ->

     

       283
       283
       +
             Printf.sprintf "invalid indentation: expected %d, got %d" expected got

     

       284
       284
       +
         | Invalid_flow_indentation -> "invalid indentation in flow construct"

     

       285
       285
       +
         | Tab_in_indentation -> "tab character in indentation"

     

       286
       286
       +
         | Invalid_block_scalar_header s ->

     

       287
       287
       +
             Printf.sprintf "invalid block scalar header: %s" s

     

       288
       288
       +
         | Invalid_quoted_scalar_indentation s ->

     

       289
       289
       +
             Printf.sprintf "%s" s

     

       290
       290
       +
         | Invalid_directive s -> Printf.sprintf "invalid directive: %s" s

     

       291
       291
       +
         | Invalid_yaml_version s -> Printf.sprintf "invalid YAML version: %s" s

     

       292
       292
       +
         | Invalid_tag_directive s -> Printf.sprintf "invalid TAG directive: %s" s

     

       293
       293
       +
         | Reserved_directive s -> Printf.sprintf "reserved directive: %s" s

     

       294
       294
       +
         | Illegal_flow_key_line -> "key and ':' must be on the same line in flow context"

     

       295
       295
       +
         | Block_sequence_disallowed -> "block sequence entries are not allowed in this context"

     

       296
       296
       +
         | Unexpected_token s -> Printf.sprintf "unexpected token: %s" s

     

       297
       297
       +
         | Expected_document_start -> "expected document start '---'"

     

       298
       298
       +
         | Expected_document_end -> "expected document end '...'"

     

       299
       299
       +
         | Expected_block_entry -> "expected block entry '-'"

     

       300
       300
       +
         | Expected_key -> "expected mapping key"

     

       301
       301
       +
         | Expected_value -> "expected mapping value"

     

       302
       302
       +
         | Expected_node -> "expected node"

     

       303
       303
       +
         | Expected_scalar -> "expected scalar"

     

       304
       304
       +
         | Expected_sequence_end -> "expected sequence end ']'"

     

       305
       305
       +
         | Expected_mapping_end -> "expected mapping end '}'"

     

       306
       306
       +
         | Duplicate_anchor s -> Printf.sprintf "duplicate anchor: &%s" s

     

       307
       307
       +
         | Undefined_alias s -> Printf.sprintf "undefined alias: *%s" s

     

       308
       308
       +
         | Alias_cycle s -> Printf.sprintf "alias cycle detected: *%s" s

     

       309
       309
       +
         | Multiple_documents -> "multiple documents found when single expected"

     

       310
       310
       +
         | Mapping_key_too_long -> "mapping key too long (max 1024 characters)"

     

       311
       311
       +
         | Invalid_scalar_conversion (value, typ) ->

     

       312
       312
       +
             Printf.sprintf "cannot convert %S to %s" value typ

     

       313
       313
       +
         | Type_mismatch (expected, got) ->

     

       314
       314
       +
             Printf.sprintf "type mismatch: expected %s, got %s" expected got

     

       315
       315
       +
         | Unresolved_alias s -> Printf.sprintf "unresolved alias: *%s" s

     

       316
       316
       +
         | Key_not_found s -> Printf.sprintf "key not found: %s" s

     

       317
       317
       +
         | Alias_expansion_node_limit n ->

     

       318
       318
       +
             Printf.sprintf "alias expansion exceeded node limit (%d nodes)" n

     

       319
       319
       +
         | Alias_expansion_depth_limit n ->

     

       320
       320
       +
             Printf.sprintf "alias expansion exceeded depth limit (%d levels)" n

     

       321
       321
       +
         | Invalid_encoding s -> Printf.sprintf "invalid encoding: %s" s

     

       322
       322
       +
         | Scalar_contains_invalid_chars s ->

     

       323
       323
       +
             Printf.sprintf "scalar contains invalid characters: %s" s

     

       324
       324
       +
         | Anchor_not_set -> "anchor not set"

     

       325
       325
       +
         | Invalid_state s -> Printf.sprintf "invalid state: %s" s

     

       326
       326
       +
         | Custom s -> s

     

       327
       327
       +
       

     

       328
       328
       +
       (** [to_string t] converts an error to a human-readable string.

     

       329
       329
       +
       

     

       330
       330
       +
           Includes error kind, source location (if available), and context stack. *)

     

       331
       331
       +
       let to_string t =

     

       332
       332
       +
         let loc = match t.span with

     

       333
       333
       +
           | None -> ""

     

       334
       334
       +
           | Some span -> " at " ^ Span.to_string span

     

       335
       335
       +
         in

     

       336
       336
       +
         let ctx = match t.context with

     

       337
       337
       +
           | [] -> ""

     

       338
       338
       +
           | ctxs -> " (in " ^ String.concat " > " (List.rev ctxs) ^ ")"

     

       339
       339
       +
         in

     

       340
       340
       +
         kind_to_string t.kind ^ loc ^ ctx

     

       341
       341
       +
       

     

       342
       342
       +
       (** [pp fmt t] pretty-prints an error to a formatter. *)

     

       343
       343
       +
       let pp fmt t =

     

       344
       344
       +
         Format.fprintf fmt "Yamlrw error: %s" (to_string t)

     

       345
       345
       +
       

     

       346
       346
       +
       (** [pp_with_source ~source fmt t] pretty-prints an error with source context.

     

       347
       347
       +
       

     

       348
       348
       +
           Shows the error message followed by the relevant source line with

     

       349
       349
       +
           a caret (^) pointing to the error location.

     

       350
       350
       +
       

     

       351
       351
       +
           @param source The source text

     

       352
       352
       +
           @param fmt Output formatter

     

       353
       353
       +
           @param t The error to display *)

     

       354
       354
       +
       let pp_with_source ~source fmt t =

     

       355
       355
       +
       let extract_line source line_num =

     

       356
       356
       +
         let lines = String.split_on_char '\n' source in

     

       357
       357
       +
         if line_num >= 1 && line_num <= List.length lines then

     

       358
       358
       +
           Some (List.nth lines (line_num - 1))

     

       359
       359
       +
         else

     

       360
       360
       +
           None

     

       361
       361
       +
         in

     

       362
       362
       +
       

     

       363
       363
       +
         pp fmt t;

     

       364
       364
       +
         match t.span with

     

       365
       365
       +
         | None -> ()

     

       366
       366
       +
         | Some span ->

     

       367
       367
       +
             match extract_line source span.start.line with

     

       368
       368
       +
             | None -> ()

     

       369
       369
       +
             | Some line ->

     

       370
       370
       +
                 Format.fprintf fmt "\n  %d | %s\n" span.start.line line;

     

       371
       371
       +
                 let padding = String.make (span.start.column - 1) ' ' in

     

       372
       372
       +
                 Format.fprintf fmt "    | %s^" padding

+82

lib/event.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
       +
       (** YAML parser events *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t =

     

       9
       9
       +
         | Stream_start of { encoding : Encoding.t }

     

       10
       10
       +
         | Stream_end

     

       11
       11
       +
         | Document_start of {

     

       12
       12
       +
             version : (int * int) option;

     

       13
       13
       +
             implicit : bool;

     

       14
       14
       +
           }

     

       15
       15
       +
         | Document_end of { implicit : bool }

     

       16
       16
       +
         | Alias of { anchor : string }

     

       17
       17
       +
         | Scalar of {

     

       18
       18
       +
             anchor : string option;

     

       19
       19
       +
             tag : string option;

     

       20
       20
       +
             value : string;

     

       21
       21
       +
             plain_implicit : bool;

     

       22
       22
       +
             quoted_implicit : bool;

     

       23
       23
       +
             style : Scalar_style.t;

     

       24
       24
       +
           }

     

       25
       25
       +
         | Sequence_start of {

     

       26
       26
       +
             anchor : string option;

     

       27
       27
       +
             tag : string option;

     

       28
       28
       +
             implicit : bool;

     

       29
       29
       +
             style : Layout_style.t;

     

       30
       30
       +
           }

     

       31
       31
       +
         | Sequence_end

     

       32
       32
       +
         | Mapping_start of {

     

       33
       33
       +
             anchor : string option;

     

       34
       34
       +
             tag : string option;

     

       35
       35
       +
             implicit : bool;

     

       36
       36
       +
             style : Layout_style.t;

     

       37
       37
       +
           }

     

       38
       38
       +
         | Mapping_end

     

       39
       39
       +
       

     

       40
       40
       +
       type spanned = {

     

       41
       41
       +
         event : t;

     

       42
       42
       +
         span : Span.t;

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       let pp fmt = function

     

       46
       46
       +
         | Stream_start { encoding } ->

     

       47
       47
       +
             Format.fprintf fmt "stream-start(%a)" Encoding.pp encoding

     

       48
       48
       +
         | Stream_end ->

     

       49
       49
       +
             Format.fprintf fmt "stream-end"

     

       50
       50
       +
         | Document_start { version; implicit } ->

     

       51
       51
       +
             Format.fprintf fmt "document-start(version=%s, implicit=%b)"

     

       52
       52
       +
               (match version with None -> "none" | Some (maj, min) -> Printf.sprintf "%d.%d" maj min)

     

       53
       53
       +
               implicit

     

       54
       54
       +
         | Document_end { implicit } ->

     

       55
       55
       +
             Format.fprintf fmt "document-end(implicit=%b)" implicit

     

       56
       56
       +
         | Alias { anchor } ->

     

       57
       57
       +
             Format.fprintf fmt "alias(%s)" anchor

     

       58
       58
       +
         | Scalar { anchor; tag; value; style; _ } ->

     

       59
       59
       +
             Format.fprintf fmt "scalar(anchor=%s, tag=%s, style=%a, value=%S)"

     

       60
       60
       +
               (Option.value anchor ~default:"none")

     

       61
       61
       +
               (Option.value tag ~default:"none")

     

       62
       62
       +
               Scalar_style.pp style

     

       63
       63
       +
               value

     

       64
       64
       +
         | Sequence_start { anchor; tag; implicit; style } ->

     

       65
       65
       +
             Format.fprintf fmt "sequence-start(anchor=%s, tag=%s, implicit=%b, style=%a)"

     

       66
       66
       +
               (Option.value anchor ~default:"none")

     

       67
       67
       +
               (Option.value tag ~default:"none")

     

       68
       68
       +
               implicit

     

       69
       69
       +
               Layout_style.pp style

     

       70
       70
       +
         | Sequence_end ->

     

       71
       71
       +
             Format.fprintf fmt "sequence-end"

     

       72
       72
       +
         | Mapping_start { anchor; tag; implicit; style } ->

     

       73
       73
       +
             Format.fprintf fmt "mapping-start(anchor=%s, tag=%s, implicit=%b, style=%a)"

     

       74
       74
       +
               (Option.value anchor ~default:"none")

     

       75
       75
       +
               (Option.value tag ~default:"none")

     

       76
       76
       +
               implicit

     

       77
       77
       +
               Layout_style.pp style

     

       78
       78
       +
         | Mapping_end ->

     

       79
       79
       +
             Format.fprintf fmt "mapping-end"

     

       80
       80
       +
       

     

       81
       81
       +
       let pp_spanned fmt { event; span } =

     

       82
       82
       +
         Format.fprintf fmt "%a at %a" pp event Span.pp span

+272

lib/input.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
       +
       (** Character input source with lookahead, based on Bytes.Reader.t

     

       7
       7
       +
       

     

       8
       8
       +
           This module wraps a bytesrw [Bytes.Reader.t] to provide character-by-character

     

       9
       9
       +
           access with lookahead for the YAML scanner. Uses bytesrw's sniff and push_back

     

       10
       10
       +
           for efficient lookahead without excessive copying.

     

       11
       11
       +
       

     

       12
       12
       +
           The same input type works with any reader source: strings, files, channels,

     

       13
       13
       +
           or streaming sources like Eio. *)

     

       14
       14
       +
       

     

       15
       15
       +
       open Bytesrw

     

       16
       16
       +
       

     

       17
       17
       +
       (** Re-export character classification *)

     

       18
       18
       +
       include Char_class

     

       19
       19
       +
       

     

       20
       20
       +
       type t = {

     

       21
       21
       +
         reader : Bytes.Reader.t;

     

       22
       22
       +
         mutable current_slice : Bytes.Slice.t option;  (** Current slice being consumed *)

     

       23
       23
       +
         mutable slice_pos : int;                        (** Position within current slice *)

     

       24
       24
       +
         mutable position : Position.t;                  (** Line/column tracking *)

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       (** Ensure we have a current slice. Returns true if data available. *)

     

       28
       28
       +
       let ensure_slice t =

     

       29
       29
       +
         match t.current_slice with

     

       30
       30
       +
         | Some slice when t.slice_pos < Bytes.Slice.length slice -> true

     

       31
       31
       +
         | _ ->

     

       32
       32
       +
             let slice = Bytes.Reader.read t.reader in

     

       33
       33
       +
             if Bytes.Slice.is_eod slice then begin

     

       34
       34
       +
               t.current_slice <- None;

     

       35
       35
       +
               false

     

       36
       36
       +
             end else begin

     

       37
       37
       +
               t.current_slice <- Some slice;

     

       38
       38
       +
               t.slice_pos <- 0;

     

       39
       39
       +
               true

     

       40
       40
       +
             end

     

       41
       41
       +
       

     

       42
       42
       +
       (** Get current character without advancing *)

     

       43
       43
       +
       let peek_current t =

     

       44
       44
       +
         match t.current_slice with

     

       45
       45
       +
         | Some slice when t.slice_pos < Bytes.Slice.length slice ->

     

       46
       46
       +
             let bytes = Bytes.Slice.bytes slice in

     

       47
       47
       +
             let first = Bytes.Slice.first slice in

     

       48
       48
       +
             Some (Stdlib.Bytes.get bytes (first + t.slice_pos))

     

       49
       49
       +
         | _ -> None

     

       50
       50
       +
       

     

       51
       51
       +
       (** Create input from a Bytes.Reader.t *)

     

       52
       52
       +
       let of_reader ?(initial_position = Position.initial) reader =

     

       53
       53
       +
         let t = {

     

       54
       54
       +
           reader;

     

       55
       55
       +
           current_slice = None;

     

       56
       56
       +
           slice_pos = 0;

     

       57
       57
       +
           position = initial_position;

     

       58
       58
       +
         } in

     

       59
       59
       +
         (* Use sniff for BOM detection - this is exactly what sniff is for *)

     

       60
       60
       +
         let sample = Bytes.Reader.sniff 4 t.reader in

     

       61
       61
       +
         let bom_len =

     

       62
       62
       +
           if String.length sample >= 3 &&

     

       63
       63
       +
              sample.[0] = '\xEF' &&

     

       64
       64
       +
              sample.[1] = '\xBB' &&

     

       65
       65
       +
              sample.[2] = '\xBF'

     

       66
       66
       +
           then 3  (* UTF-8 BOM *)

     

       67
       67
       +
           else 0

     

       68
       68
       +
         in

     

       69
       69
       +
         (* Skip BOM if present *)

     

       70
       70
       +
         if bom_len > 0 then

     

       71
       71
       +
           Bytes.Reader.skip bom_len t.reader;

     

       72
       72
       +
         t

     

       73
       73
       +
       

     

       74
       74
       +
       (** Create input from a string *)

     

       75
       75
       +
       let of_string s =

     

       76
       76
       +
         let reader = Bytes.Reader.of_string s in

     

       77
       77
       +
         of_reader reader

     

       78
       78
       +
       

     

       79
       79
       +
       let position t = t.position

     

       80
       80
       +
       

     

       81
       81
       +
       let is_eof t =

     

       82
       82
       +
         not (ensure_slice t)

     

       83
       83
       +
       

     

       84
       84
       +
       let peek t =

     

       85
       85
       +
         if ensure_slice t then

     

       86
       86
       +
           peek_current t

     

       87
       87
       +
         else

     

       88
       88
       +
           None

     

       89
       89
       +
       

     

       90
       90
       +
       let peek_exn t =

     

       91
       91
       +
         match peek t with

     

       92
       92
       +
         | Some c -> c

     

       93
       93
       +
         | None -> Error.raise_at t.position Unexpected_eof

     

       94
       94
       +
       

     

       95
       95
       +
       (** Peek at nth character (0-indexed from current position) *)

     

       96
       96
       +
       let peek_nth t n =

     

       97
       97
       +
         if n = 0 then peek t

     

       98
       98
       +
         else begin

     

       99
       99
       +
           (* Use sniff for lookahead - it pushes back automatically *)

     

       100
       100
       +
           let sample = Bytes.Reader.sniff (n + 1) t.reader in

     

       101
       101
       +
           (* But sniff reads from reader, and we may have a current slice.

     

       102
       102
       +
              We need to account for what's already in current_slice *)

     

       103
       103
       +
           match t.current_slice with

     

       104
       104
       +
           | Some slice ->

     

       105
       105
       +
               let slice_bytes = Bytes.Slice.bytes slice in

     

       106
       106
       +
               let slice_first = Bytes.Slice.first slice in

     

       107
       107
       +
               let slice_remaining = Bytes.Slice.length slice - t.slice_pos in

     

       108
       108
       +
               if n < slice_remaining then

     

       109
       109
       +
                 Some (Stdlib.Bytes.get slice_bytes (slice_first + t.slice_pos + n))

     

       110
       110
       +
               else begin

     

       111
       111
       +
                 (* Need to look beyond current slice *)

     

       112
       112
       +
                 let sample_offset = n - slice_remaining in

     

       113
       113
       +
                 if sample_offset < String.length sample then

     

       114
       114
       +
                   Some sample.[sample_offset]

     

       115
       115
       +
                 else

     

       116
       116
       +
                   None

     

       117
       117
       +
               end

     

       118
       118
       +
           | None ->

     

       119
       119
       +
               if n < String.length sample then

     

       120
       120
       +
                 Some sample.[n]

     

       121
       121
       +
               else

     

       122
       122
       +
                 None

     

       123
       123
       +
         end

     

       124
       124
       +
       

     

       125
       125
       +
       (** Peek at up to n characters as a string *)

     

       126
       126
       +
       let rec peek_string t n =

     

       127
       127
       +
         if n <= 0 then ""

     

       128
       128
       +
         else begin

     

       129
       129
       +
           match t.current_slice with

     

       130
       130
       +
           | Some slice ->

     

       131
       131
       +
               let slice_bytes = Bytes.Slice.bytes slice in

     

       132
       132
       +
               let slice_first = Bytes.Slice.first slice in

     

       133
       133
       +
               let slice_remaining = Bytes.Slice.length slice - t.slice_pos in

     

       134
       134
       +
               if n <= slice_remaining then

     

       135
       135
       +
                 (* All within current slice *)

     

       136
       136
       +
                 Stdlib.Bytes.sub_string slice_bytes (slice_first + t.slice_pos) n

     

       137
       137
       +
               else begin

     

       138
       138
       +
                 (* Need data from beyond current slice - use sniff *)

     

       139
       139
       +
                 let needed_from_reader = n - slice_remaining in

     

       140
       140
       +
                 let sample = Bytes.Reader.sniff needed_from_reader t.reader in

     

       141
       141
       +
                 let buf = Buffer.create n in

     

       142
       142
       +
                 Buffer.add_subbytes buf slice_bytes (slice_first + t.slice_pos) slice_remaining;

     

       143
       143
       +
                 Buffer.add_string buf sample;

     

       144
       144
       +
                 Buffer.contents buf

     

       145
       145
       +
               end

     

       146
       146
       +
           | None ->

     

       147
       147
       +
               if ensure_slice t then

     

       148
       148
       +
                 peek_string t n

     

       149
       149
       +
               else

     

       150
       150
       +
                 ""

     

       151
       151
       +
         end

     

       152
       152
       +
       

     

       153
       153
       +
       (** Consume next character *)

     

       154
       154
       +
       let next t =

     

       155
       155
       +
         if ensure_slice t then begin

     

       156
       156
       +
           match t.current_slice with

     

       157
       157
       +
           | Some slice ->

     

       158
       158
       +
               let bytes = Bytes.Slice.bytes slice in

     

       159
       159
       +
               let first = Bytes.Slice.first slice in

     

       160
       160
       +
               let c = Stdlib.Bytes.get bytes (first + t.slice_pos) in

     

       161
       161
       +
               t.slice_pos <- t.slice_pos + 1;

     

       162
       162
       +
               t.position <- Position.advance_char c t.position;

     

       163
       163
       +
               (* Check if we've exhausted this slice *)

     

       164
       164
       +
               if t.slice_pos >= Bytes.Slice.length slice then

     

       165
       165
       +
                 t.current_slice <- None;

     

       166
       166
       +
               Some c

     

       167
       167
       +
           | None -> None

     

       168
       168
       +
         end else

     

       169
       169
       +
           None

     

       170
       170
       +
       

     

       171
       171
       +
       let next_exn t =

     

       172
       172
       +
         match next t with

     

       173
       173
       +
         | Some c -> c

     

       174
       174
       +
         | None -> Error.raise_at t.position Unexpected_eof

     

       175
       175
       +
       

     

       176
       176
       +
       let skip t n =

     

       177
       177
       +
         for _ = 1 to n do

     

       178
       178
       +
           ignore (next t)

     

       179
       179
       +
         done

     

       180
       180
       +
       

     

       181
       181
       +
       let skip_while t pred =

     

       182
       182
       +
         let rec loop () =

     

       183
       183
       +
           match peek t with

     

       184
       184
       +
           | Some c when pred c -> ignore (next t); loop ()

     

       185
       185
       +
           | _ -> ()

     

       186
       186
       +
         in

     

       187
       187
       +
         loop ()

     

       188
       188
       +
       

     

       189
       189
       +
       (** Check if next char satisfies predicate *)

     

       190
       190
       +
       let next_is pred t =

     

       191
       191
       +
         match peek t with

     

       192
       192
       +
         | None -> false

     

       193
       193
       +
         | Some c -> pred c

     

       194
       194
       +
       

     

       195
       195
       +
       let next_is_break t = next_is is_break t

     

       196
       196
       +
       let next_is_blank t = next_is is_blank t

     

       197
       197
       +
       let next_is_whitespace t = next_is is_whitespace t

     

       198
       198
       +
       let next_is_digit t = next_is is_digit t

     

       199
       199
       +
       let next_is_hex t = next_is is_hex t

     

       200
       200
       +
       let next_is_alpha t = next_is is_alpha t

     

       201
       201
       +
       let next_is_indicator t = next_is is_indicator t

     

       202
       202
       +
       

     

       203
       203
       +
       (** Check if at document boundary (--- or ...) *)

     

       204
       204
       +
       let at_document_boundary t =

     

       205
       205
       +
         if t.position.column <> 1 then false

     

       206
       206
       +
         else begin

     

       207
       207
       +
           let s = peek_string t 4 in

     

       208
       208
       +
           let len = String.length s in

     

       209
       209
       +
           if len < 3 then false

     

       210
       210
       +
           else

     

       211
       211
       +
             let prefix = String.sub s 0 3 in

     

       212
       212
       +
             (prefix = "---" || prefix = "...") &&

     

       213
       213
       +
             (len = 3 || is_whitespace s.[3])

     

       214
       214
       +
         end

     

       215
       215
       +
       

     

       216
       216
       +
       (** Consume line break, handling \r\n as single break *)

     

       217
       217
       +
       let consume_break t =

     

       218
       218
       +
         match peek t with

     

       219
       219
       +
         | Some '\r' ->

     

       220
       220
       +
             ignore (next t);

     

       221
       221
       +
             (match peek t with

     

       222
       222
       +
              | Some '\n' -> ignore (next t)

     

       223
       223
       +
              | _ -> ())

     

       224
       224
       +
         | Some '\n' ->

     

       225
       225
       +
             ignore (next t)

     

       226
       226
       +
         | _ -> ()

     

       227
       227
       +
       

     

       228
       228
       +
       (** Get remaining content from current position *)

     

       229
       229
       +
       let remaining t =

     

       230
       230
       +
         let buf = Buffer.create 256 in

     

       231
       231
       +
         (* Add current slice remainder *)

     

       232
       232
       +
         (match t.current_slice with

     

       233
       233
       +
          | Some slice ->

     

       234
       234
       +
              let bytes = Bytes.Slice.bytes slice in

     

       235
       235
       +
              let first = Bytes.Slice.first slice in

     

       236
       236
       +
              let remaining = Bytes.Slice.length slice - t.slice_pos in

     

       237
       237
       +
              if remaining > 0 then

     

       238
       238
       +
                Buffer.add_subbytes buf bytes (first + t.slice_pos) remaining

     

       239
       239
       +
          | None -> ());

     

       240
       240
       +
         (* Add remaining from reader *)

     

       241
       241
       +
         Bytes.Reader.add_to_buffer buf t.reader;

     

       242
       242
       +
         Buffer.contents buf

     

       243
       243
       +
       

     

       244
       244
       +
       (** Mark current position for span creation *)

     

       245
       245
       +
       let mark t = t.position

     

       246
       246
       +
       

     

       247
       247
       +
       (** Get the character before the current position (limited lookahead) *)

     

       248
       248
       +
       let peek_back t =

     

       249
       249
       +
         match t.current_slice with

     

       250
       250
       +
         | Some slice when t.slice_pos > 0 ->

     

       251
       251
       +
             let bytes = Bytes.Slice.bytes slice in

     

       252
       252
       +
             let first = Bytes.Slice.first slice in

     

       253
       253
       +
             Some (Stdlib.Bytes.get bytes (first + t.slice_pos - 1))

     

       254
       254
       +
         | _ -> None

     

       255
       255
       +
       

     

       256
       256
       +
       (** Get a sample of the source for encoding detection.

     

       257
       257
       +
           Uses sniff to peek without consuming. *)

     

       258
       258
       +
       let source t =

     

       259
       259
       +
         (* First check current slice *)

     

       260
       260
       +
         match t.current_slice with

     

       261
       261
       +
         | Some slice ->

     

       262
       262
       +
             let bytes = Bytes.Slice.bytes slice in

     

       263
       263
       +
             let first = Bytes.Slice.first slice in

     

       264
       264
       +
             let available = min 4 (Bytes.Slice.length slice - t.slice_pos) in

     

       265
       265
       +
             Stdlib.Bytes.sub_string bytes (first + t.slice_pos) available

     

       266
       266
       +
         | None ->

     

       267
       267
       +
             (* Use sniff to peek at reader *)

     

       268
       268
       +
             Bytes.Reader.sniff 4 t.reader

     

       269
       269
       +
       

     

       270
       270
       +
       (** Get the byte position in the underlying stream *)

     

       271
       271
       +
       let byte_pos t =

     

       272
       272
       +
         Bytes.Reader.pos t.reader

+30

lib/layout_style.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
       +
       (** Collection layout styles *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t = [

     

       9
       9
       +
         | `Any   (** Let emitter choose *)

     

       10
       10
       +
         | `Block (** Indentation-based *)

     

       11
       11
       +
         | `Flow  (** Inline with brackets *)

     

       12
       12
       +
       ]

     

       13
       13
       +
       

     

       14
       14
       +
       let to_string = function

     

       15
       15
       +
         | `Any -> "any"

     

       16
       16
       +
         | `Block -> "block"

     

       17
       17
       +
         | `Flow -> "flow"

     

       18
       18
       +
       

     

       19
       19
       +
       let pp fmt t =

     

       20
       20
       +
         Format.pp_print_string fmt (to_string t)

     

       21
       21
       +
       

     

       22
       22
       +
       let equal a b = a = b

     

       23
       23
       +
       

     

       24
       24
       +
       let compare a b =

     

       25
       25
       +
         let to_int = function

     

       26
       26
       +
           | `Any -> 0

     

       27
       27
       +
           | `Block -> 1

     

       28
       28
       +
           | `Flow -> 2

     

       29
       29
       +
         in

     

       30
       30
       +
         Int.compare (to_int a) (to_int b)

+416

lib/loader.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
       +
       (** Loader - converts parser events to YAML data structures *)

     

       7
       7
       +
       

     

       8
       8
       +
       (** Stack frame for building nested structures *)

     

       9
       9
       +
       type frame =

     

       10
       10
       +
         | Sequence_frame of {

     

       11
       11
       +
             anchor : string option;

     

       12
       12
       +
             tag : string option;

     

       13
       13
       +
             implicit : bool;

     

       14
       14
       +
             style : Layout_style.t;

     

       15
       15
       +
             items : Yaml.t list;

     

       16
       16
       +
           }

     

       17
       17
       +
         | Mapping_frame of {

     

       18
       18
       +
             anchor : string option;

     

       19
       19
       +
             tag : string option;

     

       20
       20
       +
             implicit : bool;

     

       21
       21
       +
             style : Layout_style.t;

     

       22
       22
       +
             pairs : (Yaml.t * Yaml.t) list;

     

       23
       23
       +
             pending_key : Yaml.t option;

     

       24
       24
       +
           }

     

       25
       25
       +
       

     

       26
       26
       +
       type state = {

     

       27
       27
       +
         mutable stack : frame list;

     

       28
       28
       +
         mutable current : Yaml.t option;

     

       29
       29
       +
         mutable documents : Document.t list;

     

       30
       30
       +
         mutable doc_version : (int * int) option;

     

       31
       31
       +
         mutable doc_implicit_start : bool;

     

       32
       32
       +
       }

     

       33
       33
       +
       

     

       34
       34
       +
       let create_state () = {

     

       35
       35
       +
         stack = [];

     

       36
       36
       +
         current = None;

     

       37
       37
       +
         documents = [];

     

       38
       38
       +
         doc_version = None;

     

       39
       39
       +
         doc_implicit_start = true;

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       (** Process a single event *)

     

       43
       43
       +
       let rec process_event state (ev : Event.spanned) =

     

       44
       44
       +
         match ev.event with

     

       45
       45
       +
         | Event.Stream_start _ -> ()

     

       46
       46
       +
       

     

       47
       47
       +
         | Event.Stream_end -> ()

     

       48
       48
       +
       

     

       49
       49
       +
         | Event.Document_start { version; implicit } ->

     

       50
       50
       +
             state.doc_version <- version;

     

       51
       51
       +
             state.doc_implicit_start <- implicit

     

       52
       52
       +
       

     

       53
       53
       +
         | Event.Document_end { implicit } ->

     

       54
       54
       +
             let doc = Document.make

     

       55
       55
       +
               ?version:state.doc_version

     

       56
       56
       +
               ~implicit_start:state.doc_implicit_start

     

       57
       57
       +
               ~implicit_end:implicit

     

       58
       58
       +
               state.current

     

       59
       59
       +
             in

     

       60
       60
       +
             state.documents <- doc :: state.documents;

     

       61
       61
       +
             state.current <- None;

     

       62
       62
       +
             state.doc_version <- None;

     

       63
       63
       +
             state.doc_implicit_start <- true

     

       64
       64
       +
       

     

       65
       65
       +
         | Event.Alias { anchor } ->

     

       66
       66
       +
             let node : Yaml.t = `Alias anchor in

     

       67
       67
       +
             add_node state node

     

       68
       68
       +
       

     

       69
       69
       +
         | Event.Scalar { anchor; tag; value; plain_implicit; quoted_implicit; style } ->

     

       70
       70
       +
             let scalar = Scalar.make

     

       71
       71
       +
               ?anchor ?tag

     

       72
       72
       +
               ~plain_implicit ~quoted_implicit

     

       73
       73
       +
               ~style value

     

       74
       74
       +
             in

     

       75
       75
       +
             let node : Yaml.t = `Scalar scalar in

     

       76
       76
       +
             add_node state node

     

       77
       77
       +
       

     

       78
       78
       +
         | Event.Sequence_start { anchor; tag; implicit; style } ->

     

       79
       79
       +
             let frame = Sequence_frame {

     

       80
       80
       +
               anchor; tag; implicit; style;

     

       81
       81
       +
               items = [];

     

       82
       82
       +
             } in

     

       83
       83
       +
             state.stack <- frame :: state.stack

     

       84
       84
       +
       

     

       85
       85
       +
         | Event.Sequence_end ->

     

       86
       86
       +
             (match state.stack with

     

       87
       87
       +
              | Sequence_frame { anchor; tag; implicit; style; items } :: rest ->

     

       88
       88
       +
                  let seq = Sequence.make ?anchor ?tag ~implicit ~style (List.rev items) in

     

       89
       89
       +
                  let node : Yaml.t = `A seq in

     

       90
       90
       +
                  state.stack <- rest;

     

       91
       91
       +
                  add_node state node

     

       92
       92
       +
              | _ -> Error.raise (Invalid_state "unexpected sequence end"))

     

       93
       93
       +
       

     

       94
       94
       +
         | Event.Mapping_start { anchor; tag; implicit; style } ->

     

       95
       95
       +
             let frame = Mapping_frame {

     

       96
       96
       +
               anchor; tag; implicit; style;

     

       97
       97
       +
               pairs = [];

     

       98
       98
       +
               pending_key = None;

     

       99
       99
       +
             } in

     

       100
       100
       +
             state.stack <- frame :: state.stack

     

       101
       101
       +
       

     

       102
       102
       +
         | Event.Mapping_end ->

     

       103
       103
       +
             (match state.stack with

     

       104
       104
       +
              | Mapping_frame { anchor; tag; implicit; style; pairs; pending_key = None } :: rest ->

     

       105
       105
       +
                  let map = Mapping.make ?anchor ?tag ~implicit ~style (List.rev pairs) in

     

       106
       106
       +
                  let node : Yaml.t = `O map in

     

       107
       107
       +
                  state.stack <- rest;

     

       108
       108
       +
                  add_node state node

     

       109
       109
       +
              | Mapping_frame { pending_key = Some _; _ } :: _ ->

     

       110
       110
       +
                  Error.raise (Invalid_state "mapping ended with pending key")

     

       111
       111
       +
              | _ -> Error.raise (Invalid_state "unexpected mapping end"))

     

       112
       112
       +
       

     

       113
       113
       +
       (** Add a node to current context *)

     

       114
       114
       +
       and add_node state node =

     

       115
       115
       +
         match state.stack with

     

       116
       116
       +
         | [] ->

     

       117
       117
       +
             state.current <- Some node

     

       118
       118
       +
       

     

       119
       119
       +
         | Sequence_frame f :: rest ->

     

       120
       120
       +
             state.stack <- Sequence_frame { f with items = node :: f.items } :: rest

     

       121
       121
       +
       

     

       122
       122
       +
         | Mapping_frame f :: rest ->

     

       123
       123
       +
             (match f.pending_key with

     

       124
       124
       +
              | None ->

     

       125
       125
       +
                  (* This is a key *)

     

       126
       126
       +
                  state.stack <- Mapping_frame { f with pending_key = Some node } :: rest

     

       127
       127
       +
              | Some key ->

     

       128
       128
       +
                  (* This is a value *)

     

       129
       129
       +
                  state.stack <- Mapping_frame {

     

       130
       130
       +
                    f with

     

       131
       131
       +
                    pairs = (key, node) :: f.pairs;

     

       132
       132
       +
                    pending_key = None;

     

       133
       133
       +
                  } :: rest)

     

       134
       134
       +
       

     

       135
       135
       +
       (** Load single document as Value.

     

       136
       136
       +
       

     

       137
       137
       +
           @param resolve_aliases Whether to resolve aliases (default true)

     

       138
       138
       +
           @param max_nodes Maximum nodes during alias expansion (default 10M)

     

       139
       139
       +
           @param max_depth Maximum alias nesting depth (default 100)

     

       140
       140
       +
       *)

     

       141
       141
       +
       let value_of_string

     

       142
       142
       +
           ?(resolve_aliases = true)

     

       143
       143
       +
           ?(max_nodes = Yaml.default_max_alias_nodes)

     

       144
       144
       +
           ?(max_depth = Yaml.default_max_alias_depth)

     

       145
       145
       +
           s =

     

       146
       146
       +
         let parser = Parser.of_string s in

     

       147
       147
       +
         let state = create_state () in

     

       148
       148
       +
         Parser.iter (process_event state) parser;

     

       149
       149
       +
         match state.documents with

     

       150
       150
       +
         | [] -> `Null

     

       151
       151
       +
         | [doc] ->

     

       152
       152
       +
             (match Document.root doc with

     

       153
       153
       +
              | None -> `Null

     

       154
       154
       +
              | Some yaml ->

     

       155
       155
       +
                  Yaml.to_value ~resolve_aliases_first:resolve_aliases ~max_nodes ~max_depth yaml)

     

       156
       156
       +
         | _ -> Error.raise Multiple_documents

     

       157
       157
       +
       

     

       158
       158
       +
       (** Load single document as Yaml.

     

       159
       159
       +
       

     

       160
       160
       +
           @param resolve_aliases Whether to resolve aliases (default false for Yaml.t)

     

       161
       161
       +
           @param max_nodes Maximum nodes during alias expansion (default 10M)

     

       162
       162
       +
           @param max_depth Maximum alias nesting depth (default 100)

     

       163
       163
       +
       *)

     

       164
       164
       +
       let yaml_of_string

     

       165
       165
       +
           ?(resolve_aliases = false)

     

       166
       166
       +
           ?(max_nodes = Yaml.default_max_alias_nodes)

     

       167
       167
       +
           ?(max_depth = Yaml.default_max_alias_depth)

     

       168
       168
       +
           s =

     

       169
       169
       +
         let parser = Parser.of_string s in

     

       170
       170
       +
         let state = create_state () in

     

       171
       171
       +
         Parser.iter (process_event state) parser;

     

       172
       172
       +
         match state.documents with

     

       173
       173
       +
         | [] -> `Scalar (Scalar.make "")

     

       174
       174
       +
         | [doc] ->

     

       175
       175
       +
             (match Document.root doc with

     

       176
       176
       +
              | None -> `Scalar (Scalar.make "")

     

       177
       177
       +
              | Some yaml ->

     

       178
       178
       +
                  if resolve_aliases then

     

       179
       179
       +
                    Yaml.resolve_aliases ~max_nodes ~max_depth yaml

     

       180
       180
       +
                  else

     

       181
       181
       +
                    yaml)

     

       182
       182
       +
         | _ -> Error.raise Multiple_documents

     

       183
       183
       +
       

     

       184
       184
       +
       (** Load all documents *)

     

       185
       185
       +
       let documents_of_string s =

     

       186
       186
       +
         let parser = Parser.of_string s in

     

       187
       187
       +
         let state = create_state () in

     

       188
       188
       +
         Parser.iter (process_event state) parser;

     

       189
       189
       +
         List.rev state.documents

     

       190
       190
       +
       

     

       191
       191
       +
       (** {2 Reader-based loading} *)

     

       192
       192
       +
       

     

       193
       193
       +
       (** Load single document as Value from a Bytes.Reader.

     

       194
       194
       +
       

     

       195
       195
       +
           @param resolve_aliases Whether to resolve aliases (default true)

     

       196
       196
       +
           @param max_nodes Maximum nodes during alias expansion (default 10M)

     

       197
       197
       +
           @param max_depth Maximum alias nesting depth (default 100)

     

       198
       198
       +
       *)

     

       199
       199
       +
       let value_of_reader

     

       200
       200
       +
           ?(resolve_aliases = true)

     

       201
       201
       +
           ?(max_nodes = Yaml.default_max_alias_nodes)

     

       202
       202
       +
           ?(max_depth = Yaml.default_max_alias_depth)

     

       203
       203
       +
           reader =

     

       204
       204
       +
         let parser = Parser.of_reader reader in

     

       205
       205
       +
         let state = create_state () in

     

       206
       206
       +
         Parser.iter (process_event state) parser;

     

       207
       207
       +
         match state.documents with

     

       208
       208
       +
         | [] -> `Null

     

       209
       209
       +
         | [doc] ->

     

       210
       210
       +
             (match Document.root doc with

     

       211
       211
       +
              | None -> `Null

     

       212
       212
       +
              | Some yaml ->

     

       213
       213
       +
                  Yaml.to_value ~resolve_aliases_first:resolve_aliases ~max_nodes ~max_depth yaml)

     

       214
       214
       +
         | _ -> Error.raise Multiple_documents

     

       215
       215
       +
       

     

       216
       216
       +
       (** Load single document as Yaml from a Bytes.Reader.

     

       217
       217
       +
       

     

       218
       218
       +
           @param resolve_aliases Whether to resolve aliases (default false for Yaml.t)

     

       219
       219
       +
           @param max_nodes Maximum nodes during alias expansion (default 10M)

     

       220
       220
       +
           @param max_depth Maximum alias nesting depth (default 100)

     

       221
       221
       +
       *)

     

       222
       222
       +
       let yaml_of_reader

     

       223
       223
       +
           ?(resolve_aliases = false)

     

       224
       224
       +
           ?(max_nodes = Yaml.default_max_alias_nodes)

     

       225
       225
       +
           ?(max_depth = Yaml.default_max_alias_depth)

     

       226
       226
       +
           reader =

     

       227
       227
       +
         let parser = Parser.of_reader reader in

     

       228
       228
       +
         let state = create_state () in

     

       229
       229
       +
         Parser.iter (process_event state) parser;

     

       230
       230
       +
         match state.documents with

     

       231
       231
       +
         | [] -> `Scalar (Scalar.make "")

     

       232
       232
       +
         | [doc] ->

     

       233
       233
       +
             (match Document.root doc with

     

       234
       234
       +
              | None -> `Scalar (Scalar.make "")

     

       235
       235
       +
              | Some yaml ->

     

       236
       236
       +
                  if resolve_aliases then

     

       237
       237
       +
                    Yaml.resolve_aliases ~max_nodes ~max_depth yaml

     

       238
       238
       +
                  else

     

       239
       239
       +
                    yaml)

     

       240
       240
       +
         | _ -> Error.raise Multiple_documents

     

       241
       241
       +
       

     

       242
       242
       +
       (** Load all documents from a Bytes.Reader *)

     

       243
       243
       +
       let documents_of_reader reader =

     

       244
       244
       +
         let parser = Parser.of_reader reader in

     

       245
       245
       +
         let state = create_state () in

     

       246
       246
       +
         Parser.iter (process_event state) parser;

     

       247
       247
       +
         List.rev state.documents

     

       248
       248
       +
       

     

       249
       249
       +
       (** Generic document loader - extracts common pattern from load_* functions *)

     

       250
       250
       +
       let load_generic extract parser =

     

       251
       251
       +
         let state = create_state () in

     

       252
       252
       +
         let rec loop () =

     

       253
       253
       +
           match Parser.next parser with

     

       254
       254
       +
           | None -> None

     

       255
       255
       +
           | Some ev ->

     

       256
       256
       +
               process_event state ev;

     

       257
       257
       +
               match ev.event with

     

       258
       258
       +
               | Event.Document_end _ ->

     

       259
       259
       +
                   (match state.documents with

     

       260
       260
       +
                    | doc :: _ ->

     

       261
       261
       +
                        state.documents <- [];

     

       262
       262
       +
                        Some (extract doc)

     

       263
       263
       +
                    | [] -> None)

     

       264
       264
       +
               | Event.Stream_end -> None

     

       265
       265
       +
               | _ -> loop ()

     

       266
       266
       +
         in

     

       267
       267
       +
         loop ()

     

       268
       268
       +
       

     

       269
       269
       +
       (** Load single Value from parser.

     

       270
       270
       +
       

     

       271
       271
       +
           @param resolve_aliases Whether to resolve aliases (default true)

     

       272
       272
       +
           @param max_nodes Maximum nodes during alias expansion (default 10M)

     

       273
       273
       +
           @param max_depth Maximum alias nesting depth (default 100)

     

       274
       274
       +
       *)

     

       275
       275
       +
       let load_value

     

       276
       276
       +
           ?(resolve_aliases = true)

     

       277
       277
       +
           ?(max_nodes = Yaml.default_max_alias_nodes)

     

       278
       278
       +
           ?(max_depth = Yaml.default_max_alias_depth)

     

       279
       279
       +
           parser =

     

       280
       280
       +
         load_generic (fun doc ->

     

       281
       281
       +
           match Document.root doc with

     

       282
       282
       +
           | None -> `Null

     

       283
       283
       +
           | Some yaml ->

     

       284
       284
       +
               Yaml.to_value ~resolve_aliases_first:resolve_aliases ~max_nodes ~max_depth yaml

     

       285
       285
       +
         ) parser

     

       286
       286
       +
       

     

       287
       287
       +
       (** Load single Yaml from parser *)

     

       288
       288
       +
       let load_yaml parser =

     

       289
       289
       +
         load_generic (fun doc ->

     

       290
       290
       +
           Document.root doc |> Option.value ~default:(`Scalar (Scalar.make ""))

     

       291
       291
       +
         ) parser

     

       292
       292
       +
       

     

       293
       293
       +
       (** Load single Document from parser *)

     

       294
       294
       +
       let load_document parser =

     

       295
       295
       +
         load_generic Fun.id parser

     

       296
       296
       +
       

     

       297
       297
       +
       (** Iterate over documents *)

     

       298
       298
       +
       let iter_documents f parser =

     

       299
       299
       +
         let rec loop () =

     

       300
       300
       +
           match load_document parser with

     

       301
       301
       +
           | None -> ()

     

       302
       302
       +
           | Some doc -> f doc; loop ()

     

       303
       303
       +
         in

     

       304
       304
       +
         loop ()

     

       305
       305
       +
       

     

       306
       306
       +
       (** Fold over documents *)

     

       307
       307
       +
       let fold_documents f init parser =

     

       308
       308
       +
         let rec loop acc =

     

       309
       309
       +
           match load_document parser with

     

       310
       310
       +
           | None -> acc

     

       311
       311
       +
           | Some doc -> loop (f acc doc)

     

       312
       312
       +
         in

     

       313
       313
       +
         loop init

     

       314
       314
       +
       

     

       315
       315
       +
       (** {2 Parser-function based loading}

     

       316
       316
       +
       

     

       317
       317
       +
           These functions accept a [unit -> Event.spanned option] function

     

       318
       318
       +
           instead of a [Parser.t], allowing them to work with any event source

     

       319
       319
       +
           (e.g., streaming parsers). *)

     

       320
       320
       +
       

     

       321
       321
       +
       (** Generic document loader using event source function *)

     

       322
       322
       +
       let load_generic_fn extract next_event =

     

       323
       323
       +
         let state = create_state () in

     

       324
       324
       +
         let rec loop () =

     

       325
       325
       +
           match next_event () with

     

       326
       326
       +
           | None -> None

     

       327
       327
       +
           | Some ev ->

     

       328
       328
       +
               process_event state ev;

     

       329
       329
       +
               match ev.event with

     

       330
       330
       +
               | Event.Document_end _ ->

     

       331
       331
       +
                   (match state.documents with

     

       332
       332
       +
                    | doc :: _ ->

     

       333
       333
       +
                        state.documents <- [];

     

       334
       334
       +
                        Some (extract doc)

     

       335
       335
       +
                    | [] -> None)

     

       336
       336
       +
               | Event.Stream_end -> None

     

       337
       337
       +
               | _ -> loop ()

     

       338
       338
       +
         in

     

       339
       339
       +
         loop ()

     

       340
       340
       +
       

     

       341
       341
       +
       (** Load single Value from event source.

     

       342
       342
       +
       

     

       343
       343
       +
           @param resolve_aliases Whether to resolve aliases (default true)

     

       344
       344
       +
           @param max_nodes Maximum nodes during alias expansion (default 10M)

     

       345
       345
       +
           @param max_depth Maximum alias nesting depth (default 100)

     

       346
       346
       +
       *)

     

       347
       347
       +
       let value_of_parser

     

       348
       348
       +
           ?(resolve_aliases = true)

     

       349
       349
       +
           ?(max_nodes = Yaml.default_max_alias_nodes)

     

       350
       350
       +
           ?(max_depth = Yaml.default_max_alias_depth)

     

       351
       351
       +
           next_event =

     

       352
       352
       +
         match load_generic_fn (fun doc ->

     

       353
       353
       +
           match Document.root doc with

     

       354
       354
       +
           | None -> `Null

     

       355
       355
       +
           | Some yaml ->

     

       356
       356
       +
               Yaml.to_value ~resolve_aliases_first:resolve_aliases ~max_nodes ~max_depth yaml

     

       357
       357
       +
         ) next_event with

     

       358
       358
       +
         | Some v -> v

     

       359
       359
       +
         | None -> `Null

     

       360
       360
       +
       

     

       361
       361
       +
       (** Load single Yaml from event source.

     

       362
       362
       +
       

     

       363
       363
       +
           @param resolve_aliases Whether to resolve aliases (default false)

     

       364
       364
       +
           @param max_nodes Maximum nodes during alias expansion (default 10M)

     

       365
       365
       +
           @param max_depth Maximum alias nesting depth (default 100)

     

       366
       366
       +
       *)

     

       367
       367
       +
       let yaml_of_parser

     

       368
       368
       +
           ?(resolve_aliases = false)

     

       369
       369
       +
           ?(max_nodes = Yaml.default_max_alias_nodes)

     

       370
       370
       +
           ?(max_depth = Yaml.default_max_alias_depth)

     

       371
       371
       +
           next_event =

     

       372
       372
       +
         match load_generic_fn (fun doc ->

     

       373
       373
       +
           match Document.root doc with

     

       374
       374
       +
           | None -> `Scalar (Scalar.make "")

     

       375
       375
       +
           | Some yaml ->

     

       376
       376
       +
               if resolve_aliases then

     

       377
       377
       +
                 Yaml.resolve_aliases ~max_nodes ~max_depth yaml

     

       378
       378
       +
               else

     

       379
       379
       +
                 yaml

     

       380
       380
       +
         ) next_event with

     

       381
       381
       +
         | Some v -> v

     

       382
       382
       +
         | None -> `Scalar (Scalar.make "")

     

       383
       383
       +
       

     

       384
       384
       +
       (** Load single Document from event source *)

     

       385
       385
       +
       let document_of_parser next_event =

     

       386
       386
       +
         load_generic_fn Fun.id next_event

     

       387
       387
       +
       

     

       388
       388
       +
       (** Load all documents from event source *)

     

       389
       389
       +
       let documents_of_parser next_event =

     

       390
       390
       +
         let state = create_state () in

     

       391
       391
       +
         let rec loop () =

     

       392
       392
       +
           match next_event () with

     

       393
       393
       +
           | None -> List.rev state.documents

     

       394
       394
       +
           | Some ev ->

     

       395
       395
       +
               process_event state ev;

     

       396
       396
       +
               loop ()

     

       397
       397
       +
         in

     

       398
       398
       +
         loop ()

     

       399
       399
       +
       

     

       400
       400
       +
       (** Iterate over documents from event source *)

     

       401
       401
       +
       let iter_documents_parser f next_event =

     

       402
       402
       +
         let rec loop () =

     

       403
       403
       +
           match document_of_parser next_event with

     

       404
       404
       +
           | None -> ()

     

       405
       405
       +
           | Some doc -> f doc; loop ()

     

       406
       406
       +
         in

     

       407
       407
       +
         loop ()

     

       408
       408
       +
       

     

       409
       409
       +
       (** Fold over documents from event source *)

     

       410
       410
       +
       let fold_documents_parser f init next_event =

     

       411
       411
       +
         let rec loop acc =

     

       412
       412
       +
           match document_of_parser next_event with

     

       413
       413
       +
           | None -> acc

     

       414
       414
       +
           | Some doc -> loop (f acc doc)

     

       415
       415
       +
         in

     

       416
       416
       +
         loop init

+95

lib/mapping.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
       +
       (** YAML mapping (object) values with metadata *)

     

       7
       7
       +
       

     

       8
       8
       +
       type ('k, 'v) t = {

     

       9
       9
       +
         anchor : string option;

     

       10
       10
       +
         tag : string option;

     

       11
       11
       +
         implicit : bool;

     

       12
       12
       +
         style : Layout_style.t;

     

       13
       13
       +
         members : ('k * 'v) list;

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       let make

     

       17
       17
       +
           ?(anchor : string option)

     

       18
       18
       +
           ?(tag : string option)

     

       19
       19
       +
           ?(implicit = true)

     

       20
       20
       +
           ?(style = `Any)

     

       21
       21
       +
           members =

     

       22
       22
       +
         { anchor; tag; implicit; style; members }

     

       23
       23
       +
       

     

       24
       24
       +
       let members t = t.members

     

       25
       25
       +
       let anchor t = t.anchor

     

       26
       26
       +
       let tag t = t.tag

     

       27
       27
       +
       let implicit t = t.implicit

     

       28
       28
       +
       let style t = t.style

     

       29
       29
       +
       

     

       30
       30
       +
       let with_anchor anchor t = { t with anchor = Some anchor }

     

       31
       31
       +
       let with_tag tag t = { t with tag = Some tag }

     

       32
       32
       +
       let with_style style t = { t with style }

     

       33
       33
       +
       

     

       34
       34
       +
       let map_keys f t = { t with members = List.map (fun (k, v) -> (f k, v)) t.members }

     

       35
       35
       +
       let map_values f t = { t with members = List.map (fun (k, v) -> (k, f v)) t.members }

     

       36
       36
       +
       let map f t = { t with members = List.map (fun (k, v) -> f k v) t.members }

     

       37
       37
       +
       

     

       38
       38
       +
       let length t = List.length t.members

     

       39
       39
       +
       

     

       40
       40
       +
       let is_empty t = t.members = []

     

       41
       41
       +
       

     

       42
       42
       +
       let find pred t =

     

       43
       43
       +
         List.find_opt (fun (k, _) -> pred k) t.members |> Option.map snd

     

       44
       44
       +
       

     

       45
       45
       +
       let find_key pred t =

     

       46
       46
       +
         List.find_opt (fun (k, _) -> pred k) t.members

     

       47
       47
       +
       

     

       48
       48
       +
       let mem pred t =

     

       49
       49
       +
         List.exists (fun (k, _) -> pred k) t.members

     

       50
       50
       +
       

     

       51
       51
       +
       let keys t = List.map fst t.members

     

       52
       52
       +
       

     

       53
       53
       +
       let values t = List.map snd t.members

     

       54
       54
       +
       

     

       55
       55
       +
       let iter f t = List.iter (fun (k, v) -> f k v) t.members

     

       56
       56
       +
       

     

       57
       57
       +
       let fold f init t = List.fold_left (fun acc (k, v) -> f acc k v) init t.members

     

       58
       58
       +
       

     

       59
       59
       +
       let pp pp_key pp_val fmt t =

     

       60
       60
       +
         Format.fprintf fmt "@[<hv 2>mapping(@,";

     

       61
       61
       +
         (match t.anchor with

     

       62
       62
       +
          | Some a -> Format.fprintf fmt "anchor=%s,@ " a

     

       63
       63
       +
          | None -> ());

     

       64
       64
       +
         (match t.tag with

     

       65
       65
       +
          | Some tag -> Format.fprintf fmt "tag=%s,@ " tag

     

       66
       66
       +
          | None -> ());

     

       67
       67
       +
         Format.fprintf fmt "style=%a,@ " Layout_style.pp t.style;

     

       68
       68
       +
         Format.fprintf fmt "members={@,";

     

       69
       69
       +
         List.iteri (fun i (k, v) ->

     

       70
       70
       +
           if i > 0 then Format.fprintf fmt ",@ ";

     

       71
       71
       +
           Format.fprintf fmt "@[<hv 2>%a:@ %a@]" pp_key k pp_val v

     

       72
       72
       +
         ) t.members;

     

       73
       73
       +
         Format.fprintf fmt "@]@,})"

     

       74
       74
       +
       

     

       75
       75
       +
       let equal eq_k eq_v a b =

     

       76
       76
       +
         Option.equal String.equal a.anchor b.anchor &&

     

       77
       77
       +
         Option.equal String.equal a.tag b.tag &&

     

       78
       78
       +
         a.implicit = b.implicit &&

     

       79
       79
       +
         Layout_style.equal a.style b.style &&

     

       80
       80
       +
         List.equal (fun (k1, v1) (k2, v2) -> eq_k k1 k2 && eq_v v1 v2) a.members b.members

     

       81
       81
       +
       

     

       82
       82
       +
       let compare cmp_k cmp_v a b =

     

       83
       83
       +
         let c = Option.compare String.compare a.anchor b.anchor in

     

       84
       84
       +
         if c <> 0 then c else

     

       85
       85
       +
         let c = Option.compare String.compare a.tag b.tag in

     

       86
       86
       +
         if c <> 0 then c else

     

       87
       87
       +
         let c = Bool.compare a.implicit b.implicit in

     

       88
       88
       +
         if c <> 0 then c else

     

       89
       89
       +
         let c = Layout_style.compare a.style b.style in

     

       90
       90
       +
         if c <> 0 then c else

     

       91
       91
       +
         let cmp_pair (k1, v1) (k2, v2) =

     

       92
       92
       +
           let c = cmp_k k1 k2 in

     

       93
       93
       +
           if c <> 0 then c else cmp_v v1 v2

     

       94
       94
       +
         in

     

       95
       95
       +
         List.compare cmp_pair a.members b.members

+789

lib/parser.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
       +
       (** YAML parser - converts tokens to semantic events via state machine *)

     

       7
       7
       +
       

     

       8
       8
       +
       (** Parser states *)

     

       9
       9
       +
       type state =

     

       10
       10
       +
         | Stream_start

     

       11
       11
       +
         | Implicit_document_start

     

       12
       12
       +
         | Document_start

     

       13
       13
       +
         | Document_content

     

       14
       14
       +
         | Document_content_done  (* After parsing a node, check for unexpected content *)

     

       15
       15
       +
         | Document_end

     

       16
       16
       +
         | Block_node

     

       17
       17
       +
         | Block_node_or_indentless_sequence

     

       18
       18
       +
         | Flow_node

     

       19
       19
       +
         | Block_sequence_first_entry

     

       20
       20
       +
         | Block_sequence_entry

     

       21
       21
       +
         | Indentless_sequence_entry

     

       22
       22
       +
         | Block_mapping_first_key

     

       23
       23
       +
         | Block_mapping_key

     

       24
       24
       +
         | Block_mapping_value

     

       25
       25
       +
         | Flow_sequence_first_entry

     

       26
       26
       +
         | Flow_sequence_entry

     

       27
       27
       +
         | Flow_sequence_entry_mapping_key

     

       28
       28
       +
         | Flow_sequence_entry_mapping_value

     

       29
       29
       +
         | Flow_sequence_entry_mapping_end

     

       30
       30
       +
         | Flow_mapping_first_key

     

       31
       31
       +
         | Flow_mapping_key

     

       32
       32
       +
         | Flow_mapping_value

     

       33
       33
       +
         | Flow_mapping_empty_value

     

       34
       34
       +
         | End

     

       35
       35
       +
       

     

       36
       36
       +
       type t = {

     

       37
       37
       +
         scanner : Scanner.t;

     

       38
       38
       +
         mutable state : state;

     

       39
       39
       +
         mutable states : state list;  (** State stack *)

     

       40
       40
       +
         mutable marks : Span.t list;  (** Mark stack for span tracking *)

     

       41
       41
       +
         mutable version : (int * int) option;

     

       42
       42
       +
         mutable tag_directives : (string * string) list;

     

       43
       43
       +
         mutable current_token : Token.spanned option;

     

       44
       44
       +
         mutable finished : bool;

     

       45
       45
       +
         mutable explicit_doc_end : bool;  (** True if last doc ended with explicit ... *)

     

       46
       46
       +
         mutable stream_start : bool;  (** True if we haven't emitted any documents yet *)

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       let create scanner = {

     

       50
       50
       +
         scanner;

     

       51
       51
       +
         state = Stream_start;

     

       52
       52
       +
         states = [];

     

       53
       53
       +
         marks = [];

     

       54
       54
       +
         version = None;

     

       55
       55
       +
         tag_directives = [

     

       56
       56
       +
           ("!", "!");

     

       57
       57
       +
           ("!!", "tag:yaml.org,2002:");

     

       58
       58
       +
         ];

     

       59
       59
       +
         current_token = None;

     

       60
       60
       +
         finished = false;

     

       61
       61
       +
         explicit_doc_end = false;

     

       62
       62
       +
         stream_start = true;

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       let of_string s = create (Scanner.of_string s)

     

       66
       66
       +
       let of_scanner = create

     

       67
       67
       +
       let of_input i = create (Scanner.of_input i)

     

       68
       68
       +
       let of_reader r = create (Scanner.of_reader r)

     

       69
       69
       +
       

     

       70
       70
       +
       (** Get current token, fetching if needed *)

     

       71
       71
       +
       let current_token t =

     

       72
       72
       +
         match t.current_token with

     

       73
       73
       +
         | Some tok -> tok

     

       74
       74
       +
         | None ->

     

       75
       75
       +
             let tok = Scanner.next t.scanner in

     

       76
       76
       +
             t.current_token <- tok;

     

       77
       77
       +
             match tok with

     

       78
       78
       +
             | Some tok -> tok

     

       79
       79
       +
             | None -> Error.raise Unexpected_eof

     

       80
       80
       +
       

     

       81
       81
       +
       (** Peek at current token *)

     

       82
       82
       +
       let peek_token t =

     

       83
       83
       +
         match t.current_token with

     

       84
       84
       +
         | Some _ -> t.current_token

     

       85
       85
       +
         | None ->

     

       86
       86
       +
             t.current_token <- Scanner.next t.scanner;

     

       87
       87
       +
             t.current_token

     

       88
       88
       +
       

     

       89
       89
       +
       (** Skip current token *)

     

       90
       90
       +
       let skip_token t =

     

       91
       91
       +
         t.current_token <- None

     

       92
       92
       +
       

     

       93
       93
       +
       (** Check if current token matches *)

     

       94
       94
       +
       let check t pred =

     

       95
       95
       +
         match peek_token t with

     

       96
       96
       +
         | Some tok -> pred tok.token

     

       97
       97
       +
         | None -> false

     

       98
       98
       +
       

     

       99
       99
       +
       (** Check for specific token *)

     

       100
       100
       +
       let check_token t token_match =

     

       101
       101
       +
         check t token_match

     

       102
       102
       +
       

     

       103
       103
       +
       (** Push state onto stack *)

     

       104
       104
       +
       let push_state t s =

     

       105
       105
       +
         t.states <- s :: t.states

     

       106
       106
       +
       

     

       107
       107
       +
       (** Pop state from stack *)

     

       108
       108
       +
       let pop_state t =

     

       109
       109
       +
         match t.states with

     

       110
       110
       +
         | s :: rest ->

     

       111
       111
       +
             t.states <- rest;

     

       112
       112
       +
             s

     

       113
       113
       +
         | [] -> End

     

       114
       114
       +
       

     

       115
       115
       +
       (** Resolve a tag *)

     

       116
       116
       +
       let resolve_tag t ~handle ~suffix =

     

       117
       117
       +
         if handle = "" then

     

       118
       118
       +
           (* Verbatim tag - suffix is already the full URI *)

     

       119
       119
       +
           suffix

     

       120
       120
       +
         else

     

       121
       121
       +
           match List.assoc_opt handle t.tag_directives with

     

       122
       122
       +
           | Some prefix -> prefix ^ suffix

     

       123
       123
       +
           | None when handle = "!" -> "!" ^ suffix

     

       124
       124
       +
           | None -> Error.raise (Invalid_tag (handle ^ suffix))

     

       125
       125
       +
       

     

       126
       126
       +
       (** Process directives at document start *)

     

       127
       127
       +
       let process_directives t =

     

       128
       128
       +
         t.version <- None;

     

       129
       129
       +
         t.tag_directives <- [("!", "!"); ("!!", "tag:yaml.org,2002:")];

     

       130
       130
       +
       

     

       131
       131
       +
         while check t (function

     

       132
       132
       +
           | Token.Version_directive _ | Token.Tag_directive _ -> true

     

       133
       133
       +
           | _ -> false)

     

       134
       134
       +
         do

     

       135
       135
       +
           let tok = current_token t in

     

       136
       136
       +
           skip_token t;

     

       137
       137
       +
           match tok.token with

     

       138
       138
       +
           | Token.Version_directive { major; minor } ->

     

       139
       139
       +
               if t.version <> None then

     

       140
       140
       +
                 Error.raise_span tok.span (Invalid_yaml_version "duplicate YAML directive");

     

       141
       141
       +
               t.version <- Some (major, minor)

     

       142
       142
       +
           | Token.Tag_directive { handle; prefix } ->

     

       143
       143
       +
               (* Skip empty tag directives (these are reserved/unknown directives that were ignored) *)

     

       144
       144
       +
               if handle = "" && prefix = "" then

     

       145
       145
       +
                 () (* Ignore reserved directives *)

     

       146
       146
       +
               else begin

     

       147
       147
       +
                 if List.mem_assoc handle t.tag_directives &&

     

       148
       148
       +
                    handle <> "!" && handle <> "!!" then

     

       149
       149
       +
                   Error.raise_span tok.span (Invalid_tag_directive ("duplicate tag handle: " ^ handle));

     

       150
       150
       +
                 t.tag_directives <- (handle, prefix) :: t.tag_directives

     

       151
       151
       +
               end

     

       152
       152
       +
           | _ -> ()

     

       153
       153
       +
         done

     

       154
       154
       +
       

     

       155
       155
       +
       (** Parse anchor and/or tag properties *)

     

       156
       156
       +
       let parse_properties t =

     

       157
       157
       +
         let anchor = ref None in

     

       158
       158
       +
         let tag = ref None in

     

       159
       159
       +
       

     

       160
       160
       +
         while check t (function

     

       161
       161
       +
           | Token.Anchor _ | Token.Tag _ -> true

     

       162
       162
       +
           | _ -> false)

     

       163
       163
       +
         do

     

       164
       164
       +
           let tok = current_token t in

     

       165
       165
       +
           skip_token t;

     

       166
       166
       +
           match tok.token with

     

       167
       167
       +
           | Token.Anchor name ->

     

       168
       168
       +
               if Option.is_some !anchor then

     

       169
       169
       +
                 Error.raise_span tok.span (Duplicate_anchor name);

     

       170
       170
       +
               anchor := Some name

     

       171
       171
       +
           | Token.Tag { handle; suffix } ->

     

       172
       172
       +
               if Option.is_some !tag then

     

       173
       173
       +
                 Error.raise_span tok.span (Invalid_tag "duplicate tag");

     

       174
       174
       +
               let resolved =

     

       175
       175
       +
                 if handle = "" && suffix = "" then None

     

       176
       176
       +
                 else if handle = "!" && suffix = "" then Some "!"

     

       177
       177
       +
                 else Some (resolve_tag t ~handle ~suffix)

     

       178
       178
       +
               in

     

       179
       179
       +
               tag := resolved

     

       180
       180
       +
           | _ -> ()

     

       181
       181
       +
         done;

     

       182
       182
       +
         (!anchor, !tag)

     

       183
       183
       +
       

     

       184
       184
       +
       (** Empty scalar event *)

     

       185
       185
       +
       let empty_scalar_event ~anchor ~tag span =

     

       186
       186
       +
         Event.Scalar {

     

       187
       187
       +
           anchor;

     

       188
       188
       +
           tag;

     

       189
       189
       +
           value = "";

     

       190
       190
       +
           plain_implicit = tag = None;

     

       191
       191
       +
           quoted_implicit = false;

     

       192
       192
       +
           style = `Plain;

     

       193
       193
       +
         }, span

     

       194
       194
       +
       

     

       195
       195
       +
       (** Parse stream start *)

     

       196
       196
       +
       let parse_stream_start t =

     

       197
       197
       +
         let tok = current_token t in

     

       198
       198
       +
         skip_token t;

     

       199
       199
       +
         match tok.token with

     

       200
       200
       +
         | Token.Stream_start encoding ->

     

       201
       201
       +
             t.state <- Implicit_document_start;

     

       202
       202
       +
             Event.Stream_start { encoding }, tok.span

     

       203
       203
       +
         | _ ->

     

       204
       204
       +
             Error.raise_span tok.span (Unexpected_token "expected stream start")

     

       205
       205
       +
       

     

       206
       206
       +
       (** Parse document start (implicit or explicit) *)

     

       207
       207
       +
       let parse_document_start t ~implicit =

     

       208
       208
       +
         process_directives t;

     

       209
       209
       +
       

     

       210
       210
       +
         if not implicit then begin

     

       211
       211
       +
           let tok = current_token t in

     

       212
       212
       +
           match tok.token with

     

       213
       213
       +
           | Token.Document_start ->

     

       214
       214
       +
               skip_token t

     

       215
       215
       +
           | _ ->

     

       216
       216
       +
               Error.raise_span tok.span Expected_document_start

     

       217
       217
       +
         end;

     

       218
       218
       +
       

     

       219
       219
       +
         let span = match peek_token t with

     

       220
       220
       +
           | Some tok -> tok.span

     

       221
       221
       +
           | None -> Span.point Position.initial

     

       222
       222
       +
         in

     

       223
       223
       +
       

     

       224
       224
       +
         (* After first document, stream_start is false *)

     

       225
       225
       +
         t.stream_start <- false;

     

       226
       226
       +
         push_state t Document_end;

     

       227
       227
       +
         t.state <- Document_content;

     

       228
       228
       +
         Event.Document_start { version = t.version; implicit }, span

     

       229
       229
       +
       

     

       230
       230
       +
       (** Parse document end *)

     

       231
       231
       +
       let parse_document_end t =

     

       232
       232
       +
         let implicit = not (check t (function Token.Document_end -> true | _ -> false)) in

     

       233
       233
       +
         let span = match peek_token t with

     

       234
       234
       +
           | Some tok -> tok.span

     

       235
       235
       +
           | None -> Span.point Position.initial

     

       236
       236
       +
         in

     

       237
       237
       +
       

     

       238
       238
       +
         if not implicit then skip_token t;

     

       239
       239
       +
       

     

       240
       240
       +
         (* Track if this document ended explicitly with ... *)

     

       241
       241
       +
         t.explicit_doc_end <- not implicit;

     

       242
       242
       +
         t.state <- Implicit_document_start;

     

       243
       243
       +
         Event.Document_end { implicit }, span

     

       244
       244
       +
       

     

       245
       245
       +
       (** Parse node in various contexts *)

     

       246
       246
       +
       let parse_node t ~block ~indentless =

     

       247
       247
       +
         let tok = current_token t in

     

       248
       248
       +
         match tok.token with

     

       249
       249
       +
         | Token.Alias name ->

     

       250
       250
       +
             skip_token t;

     

       251
       251
       +
             t.state <- pop_state t;

     

       252
       252
       +
             Event.Alias { anchor = name }, tok.span

     

       253
       253
       +
       

     

       254
       254
       +
         | Token.Anchor _ | Token.Tag _ ->

     

       255
       255
       +
             let anchor, tag = parse_properties t in

     

       256
       256
       +
             let tok = current_token t in

     

       257
       257
       +
             (match tok.token with

     

       258
       258
       +
              | Token.Block_entry when indentless ->

     

       259
       259
       +
                  t.state <- Indentless_sequence_entry;

     

       260
       260
       +
                  Event.Sequence_start {

     

       261
       261
       +
                    anchor; tag;

     

       262
       262
       +
                    implicit = tag = None;

     

       263
       263
       +
                    style = `Block;

     

       264
       264
       +
                  }, tok.span

     

       265
       265
       +
       

     

       266
       266
       +
              | Token.Block_sequence_start when block ->

     

       267
       267
       +
                  t.state <- Block_sequence_first_entry;

     

       268
       268
       +
                  skip_token t;

     

       269
       269
       +
                  Event.Sequence_start {

     

       270
       270
       +
                    anchor; tag;

     

       271
       271
       +
                    implicit = tag = None;

     

       272
       272
       +
                    style = `Block;

     

       273
       273
       +
                  }, tok.span

     

       274
       274
       +
       

     

       275
       275
       +
              | Token.Block_mapping_start when block ->

     

       276
       276
       +
                  t.state <- Block_mapping_first_key;

     

       277
       277
       +
                  skip_token t;

     

       278
       278
       +
                  Event.Mapping_start {

     

       279
       279
       +
                    anchor; tag;

     

       280
       280
       +
                    implicit = tag = None;

     

       281
       281
       +
                    style = `Block;

     

       282
       282
       +
                  }, tok.span

     

       283
       283
       +
       

     

       284
       284
       +
              | Token.Flow_sequence_start ->

     

       285
       285
       +
                  t.state <- Flow_sequence_first_entry;

     

       286
       286
       +
                  skip_token t;

     

       287
       287
       +
                  Event.Sequence_start {

     

       288
       288
       +
                    anchor; tag;

     

       289
       289
       +
                    implicit = tag = None;

     

       290
       290
       +
                    style = `Flow;

     

       291
       291
       +
                  }, tok.span

     

       292
       292
       +
       

     

       293
       293
       +
              | Token.Flow_mapping_start ->

     

       294
       294
       +
                  t.state <- Flow_mapping_first_key;

     

       295
       295
       +
                  skip_token t;

     

       296
       296
       +
                  Event.Mapping_start {

     

       297
       297
       +
                    anchor; tag;

     

       298
       298
       +
                    implicit = tag = None;

     

       299
       299
       +
                    style = `Flow;

     

       300
       300
       +
                  }, tok.span

     

       301
       301
       +
       

     

       302
       302
       +
              | Token.Scalar { style; value } ->

     

       303
       303
       +
                  skip_token t;

     

       304
       304
       +
                  t.state <- pop_state t;

     

       305
       305
       +
                  let plain_implicit = tag = None && style = `Plain in

     

       306
       306
       +
                  let quoted_implicit = tag = None && style <> `Plain in

     

       307
       307
       +
                  Event.Scalar {

     

       308
       308
       +
                    anchor; tag; value;

     

       309
       309
       +
                    plain_implicit; quoted_implicit; style;

     

       310
       310
       +
                  }, tok.span

     

       311
       311
       +
       

     

       312
       312
       +
              | _ ->

     

       313
       313
       +
                  (* Empty node *)

     

       314
       314
       +
                  t.state <- pop_state t;

     

       315
       315
       +
                  empty_scalar_event ~anchor ~tag tok.span)

     

       316
       316
       +
       

     

       317
       317
       +
         | Token.Block_sequence_start when block ->

     

       318
       318
       +
             t.state <- Block_sequence_first_entry;

     

       319
       319
       +
             skip_token t;

     

       320
       320
       +
             Event.Sequence_start {

     

       321
       321
       +
               anchor = None; tag = None;

     

       322
       322
       +
               implicit = true;

     

       323
       323
       +
               style = `Block;

     

       324
       324
       +
             }, tok.span

     

       325
       325
       +
       

     

       326
       326
       +
         | Token.Block_mapping_start when block ->

     

       327
       327
       +
             t.state <- Block_mapping_first_key;

     

       328
       328
       +
             skip_token t;

     

       329
       329
       +
             Event.Mapping_start {

     

       330
       330
       +
               anchor = None; tag = None;

     

       331
       331
       +
               implicit = true;

     

       332
       332
       +
               style = `Block;

     

       333
       333
       +
             }, tok.span

     

       334
       334
       +
       

     

       335
       335
       +
         | Token.Flow_sequence_start ->

     

       336
       336
       +
             t.state <- Flow_sequence_first_entry;

     

       337
       337
       +
             skip_token t;

     

       338
       338
       +
             Event.Sequence_start {

     

       339
       339
       +
               anchor = None; tag = None;

     

       340
       340
       +
               implicit = true;

     

       341
       341
       +
               style = `Flow;

     

       342
       342
       +
             }, tok.span

     

       343
       343
       +
       

     

       344
       344
       +
         | Token.Flow_mapping_start ->

     

       345
       345
       +
             t.state <- Flow_mapping_first_key;

     

       346
       346
       +
             skip_token t;

     

       347
       347
       +
             Event.Mapping_start {

     

       348
       348
       +
               anchor = None; tag = None;

     

       349
       349
       +
               implicit = true;

     

       350
       350
       +
               style = `Flow;

     

       351
       351
       +
             }, tok.span

     

       352
       352
       +
       

     

       353
       353
       +
         | Token.Block_entry when indentless ->

     

       354
       354
       +
             t.state <- Indentless_sequence_entry;

     

       355
       355
       +
             Event.Sequence_start {

     

       356
       356
       +
               anchor = None; tag = None;

     

       357
       357
       +
               implicit = true;

     

       358
       358
       +
               style = `Block;

     

       359
       359
       +
             }, tok.span

     

       360
       360
       +
       

     

       361
       361
       +
         | Token.Scalar { style; value } ->

     

       362
       362
       +
             skip_token t;

     

       363
       363
       +
             t.state <- pop_state t;

     

       364
       364
       +
             let plain_implicit = style = `Plain in

     

       365
       365
       +
             let quoted_implicit = style <> `Plain in

     

       366
       366
       +
             Event.Scalar {

     

       367
       367
       +
               anchor = None; tag = None; value;

     

       368
       368
       +
               plain_implicit; quoted_implicit; style;

     

       369
       369
       +
             }, tok.span

     

       370
       370
       +
       

     

       371
       371
       +
         | _ ->

     

       372
       372
       +
             (* Empty node *)

     

       373
       373
       +
             t.state <- pop_state t;

     

       374
       374
       +
             empty_scalar_event ~anchor:None ~tag:None tok.span

     

       375
       375
       +
       

     

       376
       376
       +
       (** Parse block sequence entry *)

     

       377
       377
       +
       let parse_block_sequence_entry t =

     

       378
       378
       +
         let tok = current_token t in

     

       379
       379
       +
         match tok.token with

     

       380
       380
       +
         | Token.Block_entry ->

     

       381
       381
       +
             skip_token t;

     

       382
       382
       +
             if check t (function

     

       383
       383
       +
               | Token.Block_entry | Token.Block_end -> true

     

       384
       384
       +
               | _ -> false)

     

       385
       385
       +
             then begin

     

       386
       386
       +
               t.state <- Block_sequence_entry;

     

       387
       387
       +
               empty_scalar_event ~anchor:None ~tag:None tok.span

     

       388
       388
       +
             end else begin

     

       389
       389
       +
               push_state t Block_sequence_entry;

     

       390
       390
       +
               parse_node t ~block:true ~indentless:false

     

       391
       391
       +
             end

     

       392
       392
       +
         | Token.Block_end ->

     

       393
       393
       +
             skip_token t;

     

       394
       394
       +
             t.state <- pop_state t;

     

       395
       395
       +
             Event.Sequence_end, tok.span

     

       396
       396
       +
         | _ ->

     

       397
       397
       +
             Error.raise_span tok.span Expected_block_entry

     

       398
       398
       +
       

     

       399
       399
       +
       (** Parse block mapping key *)

     

       400
       400
       +
       let parse_block_mapping_key t =

     

       401
       401
       +
         let tok = current_token t in

     

       402
       402
       +
         match tok.token with

     

       403
       403
       +
         | Token.Key ->

     

       404
       404
       +
             skip_token t;

     

       405
       405
       +
             if check t (function

     

       406
       406
       +
               | Token.Key | Token.Value | Token.Block_end -> true

     

       407
       407
       +
               | _ -> false)

     

       408
       408
       +
             then begin

     

       409
       409
       +
               t.state <- Block_mapping_value;

     

       410
       410
       +
               empty_scalar_event ~anchor:None ~tag:None tok.span

     

       411
       411
       +
             end else begin

     

       412
       412
       +
               push_state t Block_mapping_value;

     

       413
       413
       +
               parse_node t ~block:true ~indentless:true

     

       414
       414
       +
             end

     

       415
       415
       +
         (* Handle value without explicit key - key is empty/null *)

     

       416
       416
       +
         | Token.Value ->

     

       417
       417
       +
             t.state <- Block_mapping_value;

     

       418
       418
       +
             empty_scalar_event ~anchor:None ~tag:None tok.span

     

       419
       419
       +
         | Token.Block_end ->

     

       420
       420
       +
             skip_token t;

     

       421
       421
       +
             t.state <- pop_state t;

     

       422
       422
       +
             Event.Mapping_end, tok.span

     

       423
       423
       +
         | _ ->

     

       424
       424
       +
             Error.raise_span tok.span Expected_key

     

       425
       425
       +
       

     

       426
       426
       +
       (** Parse block mapping value *)

     

       427
       427
       +
       let parse_block_mapping_value t =

     

       428
       428
       +
         let tok = current_token t in

     

       429
       429
       +
         match tok.token with

     

       430
       430
       +
         | Token.Value ->

     

       431
       431
       +
             skip_token t;

     

       432
       432
       +
             if check t (function

     

       433
       433
       +
               | Token.Key | Token.Value | Token.Block_end -> true

     

       434
       434
       +
               | _ -> false)

     

       435
       435
       +
             then begin

     

       436
       436
       +
               t.state <- Block_mapping_key;

     

       437
       437
       +
               empty_scalar_event ~anchor:None ~tag:None tok.span

     

       438
       438
       +
             end else begin

     

       439
       439
       +
               push_state t Block_mapping_key;

     

       440
       440
       +
               parse_node t ~block:true ~indentless:true

     

       441
       441
       +
             end

     

       442
       442
       +
         | _ ->

     

       443
       443
       +
             (* Implicit empty value *)

     

       444
       444
       +
             t.state <- Block_mapping_key;

     

       445
       445
       +
             empty_scalar_event ~anchor:None ~tag:None tok.span

     

       446
       446
       +
       

     

       447
       447
       +
       (** Parse indentless sequence entry *)

     

       448
       448
       +
       let parse_indentless_sequence_entry t =

     

       449
       449
       +
         let tok = current_token t in

     

       450
       450
       +
         match tok.token with

     

       451
       451
       +
         | Token.Block_entry ->

     

       452
       452
       +
             skip_token t;

     

       453
       453
       +
             if check t (function

     

       454
       454
       +
               | Token.Block_entry | Token.Key | Token.Value | Token.Block_end -> true

     

       455
       455
       +
               | _ -> false)

     

       456
       456
       +
             then begin

     

       457
       457
       +
               t.state <- Indentless_sequence_entry;

     

       458
       458
       +
               empty_scalar_event ~anchor:None ~tag:None tok.span

     

       459
       459
       +
             end else begin

     

       460
       460
       +
               push_state t Indentless_sequence_entry;

     

       461
       461
       +
               parse_node t ~block:true ~indentless:false

     

       462
       462
       +
             end

     

       463
       463
       +
         | _ ->

     

       464
       464
       +
             t.state <- pop_state t;

     

       465
       465
       +
             Event.Sequence_end, tok.span

     

       466
       466
       +
       

     

       467
       467
       +
       (** Parse flow sequence *)

     

       468
       468
       +
       let rec parse_flow_sequence_entry t ~first =

     

       469
       469
       +
         let tok = current_token t in

     

       470
       470
       +
         match tok.token with

     

       471
       471
       +
         | Token.Flow_sequence_end ->

     

       472
       472
       +
             skip_token t;

     

       473
       473
       +
             t.state <- pop_state t;

     

       474
       474
       +
             Event.Sequence_end, tok.span

     

       475
       475
       +
         | Token.Flow_entry when not first ->

     

       476
       476
       +
             skip_token t;

     

       477
       477
       +
             parse_flow_sequence_entry_internal t

     

       478
       478
       +
         | _ when first ->

     

       479
       479
       +
             parse_flow_sequence_entry_internal t

     

       480
       480
       +
         | _ ->

     

       481
       481
       +
             Error.raise_span tok.span Expected_sequence_end

     

       482
       482
       +
       

     

       483
       483
       +
       and parse_flow_sequence_entry_internal t =

     

       484
       484
       +
         let tok = current_token t in

     

       485
       485
       +
         match tok.token with

     

       486
       486
       +
         | Token.Flow_sequence_end ->

     

       487
       487
       +
             (* Trailing comma case - don't emit empty scalar, just go back to sequence entry state *)

     

       488
       488
       +
             skip_token t;

     

       489
       489
       +
             t.state <- pop_state t;

     

       490
       490
       +
             Event.Sequence_end, tok.span

     

       491
       491
       +
         | Token.Flow_entry ->

     

       492
       492
       +
             (* Double comma or comma after comma - invalid *)

     

       493
       493
       +
             Error.raise_span tok.span (Unexpected_token "unexpected ',' in flow sequence")

     

       494
       494
       +
         | Token.Key ->

     

       495
       495
       +
             skip_token t;

     

       496
       496
       +
             t.state <- Flow_sequence_entry_mapping_key;

     

       497
       497
       +
             Event.Mapping_start {

     

       498
       498
       +
               anchor = None; tag = None;

     

       499
       499
       +
               implicit = true;

     

       500
       500
       +
               style = `Flow;

     

       501
       501
       +
             }, tok.span

     

       502
       502
       +
         | Token.Value ->

     

       503
       503
       +
             (* Implicit empty key mapping: [ : value ] *)

     

       504
       504
       +
             t.state <- Flow_sequence_entry_mapping_key;

     

       505
       505
       +
             Event.Mapping_start {

     

       506
       506
       +
               anchor = None; tag = None;

     

       507
       507
       +
               implicit = true;

     

       508
       508
       +
               style = `Flow;

     

       509
       509
       +
             }, tok.span

     

       510
       510
       +
         | _ ->

     

       511
       511
       +
             push_state t Flow_sequence_entry;

     

       512
       512
       +
             parse_node t ~block:false ~indentless:false

     

       513
       513
       +
       

     

       514
       514
       +
       (** Parse flow sequence entry mapping *)

     

       515
       515
       +
       let parse_flow_sequence_entry_mapping_key t =

     

       516
       516
       +
         let tok = current_token t in

     

       517
       517
       +
         if check t (function

     

       518
       518
       +
           | Token.Value | Token.Flow_entry | Token.Flow_sequence_end -> true

     

       519
       519
       +
           | _ -> false)

     

       520
       520
       +
         then begin

     

       521
       521
       +
           t.state <- Flow_sequence_entry_mapping_value;

     

       522
       522
       +
           empty_scalar_event ~anchor:None ~tag:None tok.span

     

       523
       523
       +
         end else begin

     

       524
       524
       +
           push_state t Flow_sequence_entry_mapping_value;

     

       525
       525
       +
           parse_node t ~block:false ~indentless:false

     

       526
       526
       +
         end

     

       527
       527
       +
       

     

       528
       528
       +
       let parse_flow_sequence_entry_mapping_value t =

     

       529
       529
       +
         let tok = current_token t in

     

       530
       530
       +
         match tok.token with

     

       531
       531
       +
         | Token.Value ->

     

       532
       532
       +
             skip_token t;

     

       533
       533
       +
             if check t (function

     

       534
       534
       +
               | Token.Flow_entry | Token.Flow_sequence_end -> true

     

       535
       535
       +
               | _ -> false)

     

       536
       536
       +
             then begin

     

       537
       537
       +
               t.state <- Flow_sequence_entry_mapping_end;

     

       538
       538
       +
               empty_scalar_event ~anchor:None ~tag:None tok.span

     

       539
       539
       +
             end else begin

     

       540
       540
       +
               push_state t Flow_sequence_entry_mapping_end;

     

       541
       541
       +
               parse_node t ~block:false ~indentless:false

     

       542
       542
       +
             end

     

       543
       543
       +
         | _ ->

     

       544
       544
       +
             t.state <- Flow_sequence_entry_mapping_end;

     

       545
       545
       +
             empty_scalar_event ~anchor:None ~tag:None tok.span

     

       546
       546
       +
       

     

       547
       547
       +
       let parse_flow_sequence_entry_mapping_end t =

     

       548
       548
       +
         let tok = current_token t in

     

       549
       549
       +
         t.state <- Flow_sequence_entry;

     

       550
       550
       +
         Event.Mapping_end, tok.span

     

       551
       551
       +
       

     

       552
       552
       +
       (** Parse flow mapping *)

     

       553
       553
       +
       let rec parse_flow_mapping_key t ~first =

     

       554
       554
       +
         let tok = current_token t in

     

       555
       555
       +
         match tok.token with

     

       556
       556
       +
         | Token.Flow_mapping_end ->

     

       557
       557
       +
             skip_token t;

     

       558
       558
       +
             t.state <- pop_state t;

     

       559
       559
       +
             Event.Mapping_end, tok.span

     

       560
       560
       +
         | Token.Flow_entry when not first ->

     

       561
       561
       +
             skip_token t;

     

       562
       562
       +
             parse_flow_mapping_key_internal t

     

       563
       563
       +
         | _ when first ->

     

       564
       564
       +
             parse_flow_mapping_key_internal t

     

       565
       565
       +
         | _ ->

     

       566
       566
       +
             Error.raise_span tok.span Expected_mapping_end

     

       567
       567
       +
       

     

       568
       568
       +
       and parse_flow_mapping_key_internal t =

     

       569
       569
       +
         let tok = current_token t in

     

       570
       570
       +
         match tok.token with

     

       571
       571
       +
         | Token.Flow_mapping_end ->

     

       572
       572
       +
             (* Trailing comma case - don't emit empty scalar, just return to key state *)

     

       573
       573
       +
             skip_token t;

     

       574
       574
       +
             t.state <- pop_state t;

     

       575
       575
       +
             Event.Mapping_end, tok.span

     

       576
       576
       +
         | Token.Flow_entry ->

     

       577
       577
       +
             (* Double comma or comma after comma - invalid *)

     

       578
       578
       +
             Error.raise_span tok.span (Unexpected_token "unexpected ',' in flow mapping")

     

       579
       579
       +
         | Token.Key ->

     

       580
       580
       +
             skip_token t;

     

       581
       581
       +
             if check t (function

     

       582
       582
       +
               | Token.Value | Token.Flow_entry | Token.Flow_mapping_end -> true

     

       583
       583
       +
               | _ -> false)

     

       584
       584
       +
             then begin

     

       585
       585
       +
               t.state <- Flow_mapping_value;

     

       586
       586
       +
               empty_scalar_event ~anchor:None ~tag:None tok.span

     

       587
       587
       +
             end else begin

     

       588
       588
       +
               push_state t Flow_mapping_value;

     

       589
       589
       +
               parse_node t ~block:false ~indentless:false

     

       590
       590
       +
             end

     

       591
       591
       +
         | _ ->

     

       592
       592
       +
             push_state t Flow_mapping_value;

     

       593
       593
       +
             parse_node t ~block:false ~indentless:false

     

       594
       594
       +
       

     

       595
       595
       +
       let parse_flow_mapping_value t ~empty =

     

       596
       596
       +
         let tok = current_token t in

     

       597
       597
       +
         if empty then begin

     

       598
       598
       +
           t.state <- Flow_mapping_key;

     

       599
       599
       +
           empty_scalar_event ~anchor:None ~tag:None tok.span

     

       600
       600
       +
         end else

     

       601
       601
       +
           match tok.token with

     

       602
       602
       +
           | Token.Value ->

     

       603
       603
       +
               skip_token t;

     

       604
       604
       +
               if check t (function

     

       605
       605
       +
                 | Token.Flow_entry | Token.Flow_mapping_end -> true

     

       606
       606
       +
                 | _ -> false)

     

       607
       607
       +
               then begin

     

       608
       608
       +
                 t.state <- Flow_mapping_key;

     

       609
       609
       +
                 empty_scalar_event ~anchor:None ~tag:None tok.span

     

       610
       610
       +
               end else begin

     

       611
       611
       +
                 push_state t Flow_mapping_key;

     

       612
       612
       +
                 parse_node t ~block:false ~indentless:false

     

       613
       613
       +
               end

     

       614
       614
       +
           | _ ->

     

       615
       615
       +
               t.state <- Flow_mapping_key;

     

       616
       616
       +
               empty_scalar_event ~anchor:None ~tag:None tok.span

     

       617
       617
       +
       

     

       618
       618
       +
       (** Main state machine dispatcher *)

     

       619
       619
       +
       let rec parse t =

     

       620
       620
       +
         match t.state with

     

       621
       621
       +
         | Stream_start ->

     

       622
       622
       +
             parse_stream_start t

     

       623
       623
       +
       

     

       624
       624
       +
         | Implicit_document_start ->

     

       625
       625
       +
             (* Skip any document end markers before checking what's next *)

     

       626
       626
       +
             while check t (function Token.Document_end -> true | _ -> false) do

     

       627
       627
       +
               t.explicit_doc_end <- true;  (* Seeing ... counts as explicit end *)

     

       628
       628
       +
               skip_token t

     

       629
       629
       +
             done;

     

       630
       630
       +
       

     

       631
       631
       +
             let tok = current_token t in

     

       632
       632
       +
             (match tok.token with

     

       633
       633
       +
              | Token.Stream_end ->

     

       634
       634
       +
                  skip_token t;

     

       635
       635
       +
                  t.state <- End;

     

       636
       636
       +
                  t.finished <- true;

     

       637
       637
       +
                  Event.Stream_end, tok.span

     

       638
       638
       +
              | Token.Version_directive _ | Token.Tag_directive _ ->

     

       639
       639
       +
                  (* Directives are only allowed at stream start or after explicit ... (MUS6/01) *)

     

       640
       640
       +
                  if not t.stream_start && not t.explicit_doc_end then

     

       641
       641
       +
                    Error.raise_span tok.span (Invalid_directive "directives require explicit document end '...' before them");

     

       642
       642
       +
                  parse_document_start t ~implicit:false

     

       643
       643
       +
              | Token.Document_start ->

     

       644
       644
       +
                  parse_document_start t ~implicit:false

     

       645
       645
       +
              (* These tokens are invalid at document start - they indicate leftover junk *)

     

       646
       646
       +
              | Token.Flow_sequence_end | Token.Flow_mapping_end | Token.Flow_entry

     

       647
       647
       +
              | Token.Block_end | Token.Value ->

     

       648
       648
       +
                  Error.raise_span tok.span (Unexpected_token "unexpected token at document start")

     

       649
       649
       +
              | _ ->

     

       650
       650
       +
                  parse_document_start t ~implicit:true)

     

       651
       651
       +
       

     

       652
       652
       +
         | Document_start ->

     

       653
       653
       +
             parse_document_start t ~implicit:false

     

       654
       654
       +
       

     

       655
       655
       +
         | Document_content ->

     

       656
       656
       +
             if check t (function

     

       657
       657
       +
               | Token.Version_directive _ | Token.Tag_directive _

     

       658
       658
       +
               | Token.Document_start | Token.Document_end | Token.Stream_end -> true

     

       659
       659
       +
               | _ -> false)

     

       660
       660
       +
             then begin

     

       661
       661
       +
               let tok = current_token t in

     

       662
       662
       +
               t.state <- pop_state t;

     

       663
       663
       +
               empty_scalar_event ~anchor:None ~tag:None tok.span

     

       664
       664
       +
             end else begin

     

       665
       665
       +
               (* Push Document_content_done so we return there after parsing the node.

     

       666
       666
       +
                  This allows us to check for unexpected content after the node. *)

     

       667
       667
       +
               push_state t Document_content_done;

     

       668
       668
       +
               parse_node t ~block:true ~indentless:false

     

       669
       669
       +
             end

     

       670
       670
       +
       

     

       671
       671
       +
         | Document_content_done ->

     

       672
       672
       +
             (* After parsing a node in document content, check for unexpected content *)

     

       673
       673
       +
             if check t (function

     

       674
       674
       +
               | Token.Version_directive _ | Token.Tag_directive _

     

       675
       675
       +
               | Token.Document_start | Token.Document_end | Token.Stream_end -> true

     

       676
       676
       +
               | _ -> false)

     

       677
       677
       +
             then begin

     

       678
       678
       +
               (* Valid document boundary - continue to Document_end *)

     

       679
       679
       +
               t.state <- pop_state t;

     

       680
       680
       +
               parse t  (* Continue to emit the next event *)

     

       681
       681
       +
             end else begin

     

       682
       682
       +
               (* Unexpected content after document value - this is an error (KS4U, BS4K) *)

     

       683
       683
       +
               let tok = current_token t in

     

       684
       684
       +
               Error.raise_span tok.span

     

       685
       685
       +
                 (Unexpected_token "content not allowed after document value")

     

       686
       686
       +
             end

     

       687
       687
       +
       

     

       688
       688
       +
         | Document_end ->

     

       689
       689
       +
             parse_document_end t

     

       690
       690
       +
       

     

       691
       691
       +
         | Block_node ->

     

       692
       692
       +
             parse_node t ~block:true ~indentless:false

     

       693
       693
       +
       

     

       694
       694
       +
         | Block_node_or_indentless_sequence ->

     

       695
       695
       +
             parse_node t ~block:true ~indentless:true

     

       696
       696
       +
       

     

       697
       697
       +
         | Flow_node ->

     

       698
       698
       +
             parse_node t ~block:false ~indentless:false

     

       699
       699
       +
       

     

       700
       700
       +
         | Block_sequence_first_entry ->

     

       701
       701
       +
             t.state <- Block_sequence_entry;

     

       702
       702
       +
             parse_block_sequence_entry t

     

       703
       703
       +
       

     

       704
       704
       +
         | Block_sequence_entry ->

     

       705
       705
       +
             parse_block_sequence_entry t

     

       706
       706
       +
       

     

       707
       707
       +
         | Indentless_sequence_entry ->

     

       708
       708
       +
             parse_indentless_sequence_entry t

     

       709
       709
       +
       

     

       710
       710
       +
         | Block_mapping_first_key ->

     

       711
       711
       +
             t.state <- Block_mapping_key;

     

       712
       712
       +
             parse_block_mapping_key t

     

       713
       713
       +
       

     

       714
       714
       +
         | Block_mapping_key ->

     

       715
       715
       +
             parse_block_mapping_key t

     

       716
       716
       +
       

     

       717
       717
       +
         | Block_mapping_value ->

     

       718
       718
       +
             parse_block_mapping_value t

     

       719
       719
       +
       

     

       720
       720
       +
         | Flow_sequence_first_entry ->

     

       721
       721
       +
             parse_flow_sequence_entry t ~first:true

     

       722
       722
       +
       

     

       723
       723
       +
         | Flow_sequence_entry ->

     

       724
       724
       +
             parse_flow_sequence_entry t ~first:false

     

       725
       725
       +
       

     

       726
       726
       +
         | Flow_sequence_entry_mapping_key ->

     

       727
       727
       +
             parse_flow_sequence_entry_mapping_key t

     

       728
       728
       +
       

     

       729
       729
       +
         | Flow_sequence_entry_mapping_value ->

     

       730
       730
       +
             parse_flow_sequence_entry_mapping_value t

     

       731
       731
       +
       

     

       732
       732
       +
         | Flow_sequence_entry_mapping_end ->

     

       733
       733
       +
             parse_flow_sequence_entry_mapping_end t

     

       734
       734
       +
       

     

       735
       735
       +
         | Flow_mapping_first_key ->

     

       736
       736
       +
             parse_flow_mapping_key t ~first:true

     

       737
       737
       +
       

     

       738
       738
       +
         | Flow_mapping_key ->

     

       739
       739
       +
             parse_flow_mapping_key t ~first:false

     

       740
       740
       +
       

     

       741
       741
       +
         | Flow_mapping_value ->

     

       742
       742
       +
             parse_flow_mapping_value t ~empty:false

     

       743
       743
       +
       

     

       744
       744
       +
         | Flow_mapping_empty_value ->

     

       745
       745
       +
             parse_flow_mapping_value t ~empty:true

     

       746
       746
       +
       

     

       747
       747
       +
         | End ->

     

       748
       748
       +
             let span = Span.point Position.initial in

     

       749
       749
       +
             t.finished <- true;

     

       750
       750
       +
             Event.Stream_end, span

     

       751
       751
       +
       

     

       752
       752
       +
       (** Get next event *)

     

       753
       753
       +
       let next t =

     

       754
       754
       +
         if t.finished then None

     

       755
       755
       +
         else begin

     

       756
       756
       +
           let event, span = parse t in

     

       757
       757
       +
           Some { Event.event; span }

     

       758
       758
       +
         end

     

       759
       759
       +
       

     

       760
       760
       +
       (** Peek at next event *)

     

       761
       761
       +
       let peek t =

     

       762
       762
       +
         (* Parser is not easily peekable without full state save/restore *)

     

       763
       763
       +
         (* For now, we don't support peek - could add caching if needed *)

     

       764
       764
       +
         if t.finished then None

     

       765
       765
       +
         else

     

       766
       766
       +
           (* Just call next and the caller will have to deal with it *)

     

       767
       767
       +
           next t

     

       768
       768
       +
       

     

       769
       769
       +
       (** Iterate over all events *)

     

       770
       770
       +
       let iter f t =

     

       771
       771
       +
         let rec loop () =

     

       772
       772
       +
           match next t with

     

       773
       773
       +
           | None -> ()

     

       774
       774
       +
           | Some ev -> f ev; loop ()

     

       775
       775
       +
         in

     

       776
       776
       +
         loop ()

     

       777
       777
       +
       

     

       778
       778
       +
       (** Fold over all events *)

     

       779
       779
       +
       let fold f init t =

     

       780
       780
       +
         let rec loop acc =

     

       781
       781
       +
           match next t with

     

       782
       782
       +
           | None -> acc

     

       783
       783
       +
           | Some ev -> loop (f acc ev)

     

       784
       784
       +
         in

     

       785
       785
       +
         loop init

     

       786
       786
       +
       

     

       787
       787
       +
       (** Convert to list *)

     

       788
       788
       +
       let to_list t =

     

       789
       789
       +
         fold (fun acc ev -> ev :: acc) [] t |> List.rev

+47

lib/position.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
       +
       (** Position tracking for source locations *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t = {

     

       9
       9
       +
         index : int;   (** Byte offset from start *)

     

       10
       10
       +
         line : int;    (** 1-indexed line number *)

     

       11
       11
       +
         column : int;  (** 1-indexed column number *)

     

       12
       12
       +
       }

     

       13
       13
       +
       

     

       14
       14
       +
       let initial = { index = 0; line = 1; column = 1 }

     

       15
       15
       +
       

     

       16
       16
       +
       let advance_byte t =

     

       17
       17
       +
         { t with index = t.index + 1; column = t.column + 1 }

     

       18
       18
       +
       

     

       19
       19
       +
       let advance_line t =

     

       20
       20
       +
         { index = t.index + 1; line = t.line + 1; column = 1 }

     

       21
       21
       +
       

     

       22
       22
       +
       let advance_char c t =

     

       23
       23
       +
         if c = '\n' then advance_line t

     

       24
       24
       +
         else advance_byte t

     

       25
       25
       +
       

     

       26
       26
       +
       let advance_utf8 uchar t =

     

       27
       27
       +
         let len = Uchar.utf_8_byte_length uchar in

     

       28
       28
       +
         let code = Uchar.to_int uchar in

     

       29
       29
       +
         if code = 0x0A (* LF *) then

     

       30
       30
       +
           { index = t.index + len; line = t.line + 1; column = 1 }

     

       31
       31
       +
         else

     

       32
       32
       +
           { t with index = t.index + len; column = t.column + 1 }

     

       33
       33
       +
       

     

       34
       34
       +
       let advance_bytes n t =

     

       35
       35
       +
         { t with index = t.index + n; column = t.column + n }

     

       36
       36
       +
       

     

       37
       37
       +
       let pp fmt t =

     

       38
       38
       +
         Format.fprintf fmt "line %d, column %d" t.line t.column

     

       39
       39
       +
       

     

       40
       40
       +
       let to_string t =

     

       41
       41
       +
         Format.asprintf "%a" pp t

     

       42
       42
       +
       

     

       43
       43
       +
       let compare a b =

     

       44
       44
       +
         Int.compare a.index b.index

     

       45
       45
       +
       

     

       46
       46
       +
       let equal a b =

     

       47
       47
       +
         a.index = b.index

+62

lib/quoting.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
       +
       (** YAML scalar quoting detection *)

     

       7
       7
       +
       

     

       8
       8
       +
       (** Check if a string value needs quoting in YAML output.

     

       9
       9
       +
           Returns true if the string:

     

       10
       10
       +
           - Is empty

     

       11
       11
       +
           - Starts with an indicator character

     

       12
       12
       +
           - Is a reserved word (null, true, false, yes, no, etc.)

     

       13
       13
       +
           - Contains characters that would be ambiguous

     

       14
       14
       +
           - Looks like a number *)

     

       15
       15
       +
       let needs_quoting s =

     

       16
       16
       +
         if String.length s = 0 then true

     

       17
       17
       +
         else

     

       18
       18
       +
           let first = s.[0] in

     

       19
       19
       +
           (* Check first character for indicators *)

     

       20
       20
       +
           if first = '-' || first = '?' || first = ':' || first = ',' ||

     

       21
       21
       +
              first = '[' || first = ']' || first = '{' || first = '}' ||

     

       22
       22
       +
              first = '#' || first = '&' || first = '*' || first = '!' ||

     

       23
       23
       +
              first = '|' || first = '>' || first = '\'' || first = '"' ||

     

       24
       24
       +
              first = '%' || first = '@' || first = '`' || first = ' ' then

     

       25
       25
       +
             true

     

       26
       26
       +
           else

     

       27
       27
       +
             (* Check for reserved/special values *)

     

       28
       28
       +
             let lower = String.lowercase_ascii s in

     

       29
       29
       +
             if lower = "null" || lower = "true" || lower = "false" ||

     

       30
       30
       +
                lower = "yes" || lower = "no" || lower = "on" || lower = "off" ||

     

       31
       31
       +
                lower = "~" || lower = ".inf" || lower = "-.inf" || lower = ".nan" then

     

       32
       32
       +
               true

     

       33
       33
       +
             else

     

       34
       34
       +
               (* Check for problematic characters *)

     

       35
       35
       +
               try

     

       36
       36
       +
                 String.iter (fun c ->

     

       37
       37
       +
                   if c = ':' || c = '#' || c = '\n' || c = '\r' then

     

       38
       38
       +
                     raise Exit

     

       39
       39
       +
                 ) s;

     

       40
       40
       +
                 (* Check if it looks like a number *)

     

       41
       41
       +
                 (try ignore (Float.of_string s); true with _ -> false)

     

       42
       42
       +
               with Exit -> true

     

       43
       43
       +
       

     

       44
       44
       +
       (** Check if a string requires double quotes (vs single quotes).

     

       45
       45
       +
           Returns true if the string contains characters that need escape sequences. *)

     

       46
       46
       +
       let needs_double_quotes s =

     

       47
       47
       +
         try

     

       48
       48
       +
           String.iter (fun c ->

     

       49
       49
       +
             if c = '\n' || c = '\r' || c = '\t' || c = '\\' ||

     

       50
       50
       +
                c < ' ' || c = '"' then

     

       51
       51
       +
               raise Exit

     

       52
       52
       +
           ) s;

     

       53
       53
       +
           false

     

       54
       54
       +
         with Exit -> true

     

       55
       55
       +
       

     

       56
       56
       +
       (** Choose the appropriate quoting style for a string value *)

     

       57
       57
       +
       let choose_style s =

     

       58
       58
       +
         match (needs_double_quotes s, needs_quoting s) with

     

       59
       59
       +
         | (true, _) -> `Double_quoted

     

       60
       60
       +
         | (_, true) -> `Single_quoted

     

       61
       61
       +
         | _ -> `Plain

     

       62
       62
       +

+66

lib/scalar.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
       +
       (** YAML scalar values with metadata *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t = {

     

       9
       9
       +
         anchor : string option;

     

       10
       10
       +
         tag : string option;

     

       11
       11
       +
         value : string;

     

       12
       12
       +
         plain_implicit : bool;

     

       13
       13
       +
         quoted_implicit : bool;

     

       14
       14
       +
         style : Scalar_style.t;

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       let make

     

       18
       18
       +
           ?(anchor : string option)

     

       19
       19
       +
           ?(tag : string option)

     

       20
       20
       +
           ?(plain_implicit = true)

     

       21
       21
       +
           ?(quoted_implicit = false)

     

       22
       22
       +
           ?(style = `Plain)

     

       23
       23
       +
           value =

     

       24
       24
       +
         { anchor; tag; value; plain_implicit; quoted_implicit; style }

     

       25
       25
       +
       

     

       26
       26
       +
       let value t = t.value

     

       27
       27
       +
       let anchor t = t.anchor

     

       28
       28
       +
       let tag t = t.tag

     

       29
       29
       +
       let style t = t.style

     

       30
       30
       +
       let plain_implicit t = t.plain_implicit

     

       31
       31
       +
       let quoted_implicit t = t.quoted_implicit

     

       32
       32
       +
       

     

       33
       33
       +
       let with_anchor anchor t = { t with anchor = Some anchor }

     

       34
       34
       +
       let with_tag tag t = { t with tag = Some tag }

     

       35
       35
       +
       let with_style style t = { t with style }

     

       36
       36
       +
       

     

       37
       37
       +
       let pp fmt t =

     

       38
       38
       +
         Format.fprintf fmt "scalar(%S" t.value;

     

       39
       39
       +
         (match t.anchor with

     

       40
       40
       +
          | Some a -> Format.fprintf fmt ", anchor=%s" a

     

       41
       41
       +
          | None -> ());

     

       42
       42
       +
         (match t.tag with

     

       43
       43
       +
          | Some tag -> Format.fprintf fmt ", tag=%s" tag

     

       44
       44
       +
          | None -> ());

     

       45
       45
       +
         Format.fprintf fmt ", style=%a)" Scalar_style.pp t.style

     

       46
       46
       +
       

     

       47
       47
       +
       let equal a b =

     

       48
       48
       +
         Option.equal String.equal a.anchor b.anchor &&

     

       49
       49
       +
         Option.equal String.equal a.tag b.tag &&

     

       50
       50
       +
         String.equal a.value b.value &&

     

       51
       51
       +
         a.plain_implicit = b.plain_implicit &&

     

       52
       52
       +
         a.quoted_implicit = b.quoted_implicit &&

     

       53
       53
       +
         Scalar_style.equal a.style b.style

     

       54
       54
       +
       

     

       55
       55
       +
       let compare a b =

     

       56
       56
       +
         let c = Option.compare String.compare a.anchor b.anchor in

     

       57
       57
       +
         if c <> 0 then c else

     

       58
       58
       +
         let c = Option.compare String.compare a.tag b.tag in

     

       59
       59
       +
         if c <> 0 then c else

     

       60
       60
       +
         let c = String.compare a.value b.value in

     

       61
       61
       +
         if c <> 0 then c else

     

       62
       62
       +
         let c = Bool.compare a.plain_implicit b.plain_implicit in

     

       63
       63
       +
         if c <> 0 then c else

     

       64
       64
       +
         let c = Bool.compare a.quoted_implicit b.quoted_implicit in

     

       65
       65
       +
         if c <> 0 then c else

     

       66
       66
       +
         Scalar_style.compare a.style b.style

+39

lib/scalar_style.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
       +
       (** Scalar formatting styles *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t = [

     

       9
       9
       +
         | `Any           (** Let emitter choose *)

     

       10
       10
       +
         | `Plain         (** Unquoted: foo *)

     

       11
       11
       +
         | `Single_quoted (** 'foo' *)

     

       12
       12
       +
         | `Double_quoted (** "foo" *)

     

       13
       13
       +
         | `Literal       (** | block *)

     

       14
       14
       +
         | `Folded        (** > block *)

     

       15
       15
       +
       ]

     

       16
       16
       +
       

     

       17
       17
       +
       let to_string = function

     

       18
       18
       +
         | `Any -> "any"

     

       19
       19
       +
         | `Plain -> "plain"

     

       20
       20
       +
         | `Single_quoted -> "single-quoted"

     

       21
       21
       +
         | `Double_quoted -> "double-quoted"

     

       22
       22
       +
         | `Literal -> "literal"

     

       23
       23
       +
         | `Folded -> "folded"

     

       24
       24
       +
       

     

       25
       25
       +
       let pp fmt t =

     

       26
       26
       +
         Format.pp_print_string fmt (to_string t)

     

       27
       27
       +
       

     

       28
       28
       +
       let equal a b = a = b

     

       29
       29
       +
       

     

       30
       30
       +
       let compare a b =

     

       31
       31
       +
         let to_int = function

     

       32
       32
       +
           | `Any -> 0

     

       33
       33
       +
           | `Plain -> 1

     

       34
       34
       +
           | `Single_quoted -> 2

     

       35
       35
       +
           | `Double_quoted -> 3

     

       36
       36
       +
           | `Literal -> 4

     

       37
       37
       +
           | `Folded -> 5

     

       38
       38
       +
         in

     

       39
       39
       +
         Int.compare (to_int a) (to_int b)

+1575

lib/scanner.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
       +
       (** YAML tokenizer/scanner with lookahead for ambiguity resolution *)

     

       7
       7
       +
       

     

       8
       8
       +
       (** Simple key tracking for mapping key disambiguation *)

     

       9
       9
       +
       type simple_key = {

     

       10
       10
       +
         sk_possible : bool;

     

       11
       11
       +
         sk_required : bool;

     

       12
       12
       +
         sk_token_number : int;

     

       13
       13
       +
         sk_position : Position.t;

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       (** Indent level tracking *)

     

       17
       17
       +
       type indent = {

     

       18
       18
       +
         indent : int;

     

       19
       19
       +
         needs_block_end : bool;

     

       20
       20
       +
         sequence : bool;  (** true if this is a sequence indent *)

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       type t = {

     

       24
       24
       +
         input : Input.t;

     

       25
       25
       +
         mutable tokens : Token.spanned Queue.t;

     

       26
       26
       +
         mutable token_number : int;

     

       27
       27
       +
         mutable tokens_taken : int;

     

       28
       28
       +
         mutable stream_started : bool;

     

       29
       29
       +
         mutable stream_ended : bool;

     

       30
       30
       +
         mutable indent_stack : indent list;  (** Stack of indentation levels *)

     

       31
       31
       +
         mutable flow_level : int;            (** Nesting depth in \[\] or \{\} *)

     

       32
       32
       +
         mutable flow_indent : int;           (** Column where outermost flow collection started *)

     

       33
       33
       +
         mutable simple_keys : simple_key option list;  (** Per flow-level simple key tracking *)

     

       34
       34
       +
         mutable allow_simple_key : bool;

     

       35
       35
       +
         mutable leading_whitespace : bool;   (** True when at start of line (only whitespace seen) *)

     

       36
       36
       +
         mutable document_has_content : bool; (** True if we've emitted content tokens in current document *)

     

       37
       37
       +
         mutable adjacent_value_allowed_at : Position.t option; (** Position where adjacent : is allowed *)

     

       38
       38
       +
         mutable pending_value : bool;        (** True if we've emitted a KEY and are waiting for VALUE *)

     

       39
       39
       +
         mutable flow_mapping_stack : bool list;  (** Stack of whether each flow level is a mapping *)

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       let create input =

     

       43
       43
       +
         {

     

       44
       44
       +
           input;

     

       45
       45
       +
           tokens = Queue.create ();

     

       46
       46
       +
           token_number = 0;

     

       47
       47
       +
           tokens_taken = 0;

     

       48
       48
       +
           stream_started = false;

     

       49
       49
       +
           stream_ended = false;

     

       50
       50
       +
           indent_stack = [];

     

       51
       51
       +
           flow_level = 0;

     

       52
       52
       +
           flow_indent = 0;

     

       53
       53
       +
           simple_keys = [None];  (* One entry for the base level *)

     

       54
       54
       +
           allow_simple_key = true;

     

       55
       55
       +
           leading_whitespace = true;  (* Start at beginning of stream *)

     

       56
       56
       +
           document_has_content = false;

     

       57
       57
       +
           adjacent_value_allowed_at = None;

     

       58
       58
       +
           pending_value = false;

     

       59
       59
       +
           flow_mapping_stack = [];

     

       60
       60
       +
         }

     

       61
       61
       +
       

     

       62
       62
       +
       let of_string s = create (Input.of_string s)

     

       63
       63
       +
       let of_input = create

     

       64
       64
       +
       let of_reader r = create (Input.of_reader r)

     

       65
       65
       +
       

     

       66
       66
       +
       let position t = Input.position t.input

     

       67
       67
       +
       

     

       68
       68
       +
       (** Add a token to the queue *)

     

       69
       69
       +
       let emit t span token =

     

       70
       70
       +
         Queue.add { Token.token; span } t.tokens;

     

       71
       71
       +
         t.token_number <- t.token_number + 1

     

       72
       72
       +
       

     

       73
       73
       +
       (** Get current column (1-indexed) *)

     

       74
       74
       +
       let column t = (Input.position t.input).column

     

       75
       75
       +
       

     

       76
       76
       +
       (** Get current indent level *)

     

       77
       77
       +
       let current_indent t =

     

       78
       78
       +
         match t.indent_stack with

     

       79
       79
       +
         | [] -> -1

     

       80
       80
       +
         | { indent; _ } :: _ -> indent

     

       81
       81
       +
       

     

       82
       82
       +
       (** Skip whitespace to end of line, checking for valid comments.

     

       83
       83
       +
           Returns true if any whitespace (including tabs) was found before a comment. *)

     

       84
       84
       +
       let skip_whitespace_and_comment t =

     

       85
       85
       +
         let has_whitespace = ref false in

     

       86
       86
       +
         (* Skip blanks (spaces and tabs) *)

     

       87
       87
       +
         while Input.next_is_blank t.input do

     

       88
       88
       +
           has_whitespace := true;

     

       89
       89
       +
           ignore (Input.next t.input)

     

       90
       90
       +
         done;

     

       91
       91
       +
         (* Check for comment *)

     

       92
       92
       +
         if Input.next_is (( = ) '#') t.input then begin

     

       93
       93
       +
           (* Validate: comment must be preceded by whitespace or be at start of line *)

     

       94
       94
       +
           if not !has_whitespace then begin

     

       95
       95
       +
             (* Check if we're at the start of input or after whitespace (blank or line break) *)

     

       96
       96
       +
             match Input.peek_back t.input with

     

       97
       97
       +
             | None -> () (* Start of input - OK *)

     

       98
       98
       +
             | Some c when Input.is_whitespace c -> () (* After whitespace - OK *)

     

       99
       99
       +
             | _ ->

     

       100
       100
       +
                 (* Comment not preceded by whitespace - ERROR *)

     

       101
       101
       +
                 Error.raise_at (Input.mark t.input) Invalid_comment

     

       102
       102
       +
           end;

     

       103
       103
       +
           (* Skip to end of line *)

     

       104
       104
       +
           while not (Input.is_eof t.input) && not (Input.next_is_break t.input) do

     

       105
       105
       +
             ignore (Input.next t.input)

     

       106
       106
       +
           done

     

       107
       107
       +
         end

     

       108
       108
       +
       

     

       109
       109
       +
       (** Skip blanks (spaces/tabs) and return (found_tabs, found_spaces) *)

     

       110
       110
       +
       let skip_blanks_check_tabs t =

     

       111
       111
       +
         let found_tab = ref false in

     

       112
       112
       +
         let found_space = ref false in

     

       113
       113
       +
         while Input.next_is_blank t.input do

     

       114
       114
       +
           (match Input.peek t.input with

     

       115
       115
       +
            | Some '\t' -> found_tab := true

     

       116
       116
       +
            | Some ' ' -> found_space := true

     

       117
       117
       +
            | _ -> ());

     

       118
       118
       +
           ignore (Input.next t.input)

     

       119
       119
       +
         done;

     

       120
       120
       +
         (!found_tab, !found_space)

     

       121
       121
       +
       

     

       122
       122
       +
       (** Skip whitespace and comments, return true if at newline *)

     

       123
       123
       +
       let rec skip_to_next_token t =

     

       124
       124
       +
         (* Check for tabs used as indentation in block context *)

     

       125
       125
       +
         (match Input.peek t.input with

     

       126
       126
       +
          | Some '\t' when t.flow_level = 0 && t.leading_whitespace &&

     

       127
       127
       +
                           (column t - 1) < current_indent t ->

     

       128
       128
       +
              (* Tab found in indentation zone - this is invalid *)

     

       129
       129
       +
              (* Skip to end of line to check if line has content *)

     

       130
       130
       +
              let start_pos = Input.mark t.input in

     

       131
       131
       +
              while Input.next_is_blank t.input do

     

       132
       132
       +
                ignore (Input.next t.input)

     

       133
       133
       +
              done;

     

       134
       134
       +
              (* If we have content on this line with a tab, raise error *)

     

       135
       135
       +
              if not (Input.next_is_break t.input) && not (Input.is_eof t.input) then

     

       136
       136
       +
                Error.raise_at start_pos Tab_in_indentation

     

       137
       137
       +
          | _ -> ());

     

       138
       138
       +
       

     

       139
       139
       +
         (* Skip blanks and validate comments *)

     

       140
       140
       +
         skip_whitespace_and_comment t;

     

       141
       141
       +
         (* Skip line break in block context *)

     

       142
       142
       +
         if t.flow_level = 0 && Input.next_is_break t.input then begin

     

       143
       143
       +
           Input.consume_break t.input;

     

       144
       144
       +
           t.allow_simple_key <- true;

     

       145
       145
       +
           t.leading_whitespace <- true;

     

       146
       146
       +
           skip_to_next_token t

     

       147
       147
       +
         end

     

       148
       148
       +
         else if t.flow_level > 0 && Input.next_is_whitespace t.input then begin

     

       149
       149
       +
           (* In flow context, skip all whitespace including line breaks *)

     

       150
       150
       +
           if Input.next_is_break t.input then begin

     

       151
       151
       +
             Input.consume_break t.input;

     

       152
       152
       +
             (* Allow simple keys after line breaks in flow context *)

     

       153
       153
       +
             t.allow_simple_key <- true;

     

       154
       154
       +
             (* After line break in flow, check for tabs at start of line (Y79Y/03)

     

       155
       155
       +
                Tabs are not allowed as indentation - if tab is first char and results

     

       156
       156
       +
                in a column less than flow_indent, it's an error *)

     

       157
       157
       +
             if Input.next_is (( = ) '\t') t.input then begin

     

       158
       158
       +
               (* Tab at start of line in flow context - skip tabs and check position *)

     

       159
       159
       +
               let start_mark = Input.mark t.input in

     

       160
       160
       +
               while Input.next_is (( = ) '\t') t.input do

     

       161
       161
       +
                 ignore (Input.next t.input)

     

       162
       162
       +
               done;

     

       163
       163
       +
               (* If only tabs were used (no spaces) and column < flow_indent, error *)

     

       164
       164
       +
               if not (Input.next_is_break t.input) && not (Input.is_eof t.input) &&

     

       165
       165
       +
                  column t < t.flow_indent then

     

       166
       166
       +
                 Error.raise_at start_mark Invalid_flow_indentation

     

       167
       167
       +
             end;

     

       168
       168
       +
             skip_to_next_token t

     

       169
       169
       +
           end else begin

     

       170
       170
       +
             ignore (Input.next t.input);

     

       171
       171
       +
             skip_to_next_token t

     

       172
       172
       +
           end

     

       173
       173
       +
         end

     

       174
       174
       +
       

     

       175
       175
       +
       (** Roll the indentation level *)

     

       176
       176
       +
       let roll_indent t col ~sequence =

     

       177
       177
       +
         if t.flow_level = 0 && col > current_indent t then begin

     

       178
       178
       +
           t.indent_stack <- { indent = col; needs_block_end = true; sequence } :: t.indent_stack;

     

       179
       179
       +
           true

     

       180
       180
       +
         end else

     

       181
       181
       +
           false

     

       182
       182
       +
       

     

       183
       183
       +
       (** Unroll indentation to given column *)

     

       184
       184
       +
       let unroll_indent t col =

     

       185
       185
       +
         while t.flow_level = 0 &&

     

       186
       186
       +
               match t.indent_stack with

     

       187
       187
       +
               | { indent; needs_block_end = true; _ } :: _ when indent > col -> true

     

       188
       188
       +
               | _ -> false

     

       189
       189
       +
         do

     

       190
       190
       +
           match t.indent_stack with

     

       191
       191
       +
           | { indent = _; needs_block_end = true; _ } :: rest ->

     

       192
       192
       +
               let pos = Input.position t.input in

     

       193
       193
       +
               let span = Span.point pos in

     

       194
       194
       +
               emit t span Token.Block_end;

     

       195
       195
       +
               t.indent_stack <- rest

     

       196
       196
       +
           | _ -> ()

     

       197
       197
       +
         done

     

       198
       198
       +
       

     

       199
       199
       +
       (** Save a potential simple key *)

     

       200
       200
       +
       let save_simple_key t =

     

       201
       201
       +
         if t.allow_simple_key then begin

     

       202
       202
       +
           (* A simple key is required only if we're in a block context,

     

       203
       203
       +
              at the current indentation level, AND the current indent needs a block end.

     

       204
       204
       +
              This matches saphyr's logic and prevents false positives for values. *)

     

       205
       205
       +
           let required = t.flow_level = 0 &&

     

       206
       206
       +
                          match t.indent_stack with

     

       207
       207
       +
                          | { indent; needs_block_end = true; _ } :: _ ->

     

       208
       208
       +
                              indent = column t

     

       209
       209
       +
                          | _ -> false

     

       210
       210
       +
           in

     

       211
       211
       +
           let sk = {

     

       212
       212
       +
             sk_possible = true;

     

       213
       213
       +
             sk_required = required;

     

       214
       214
       +
             sk_token_number = t.token_number;

     

       215
       215
       +
             sk_position = Input.position t.input;

     

       216
       216
       +
           } in

     

       217
       217
       +
           (* Remove any existing simple key at current level *)

     

       218
       218
       +
           t.simple_keys <- (

     

       219
       219
       +
             match t.simple_keys with

     

       220
       220
       +
             | _ :: rest -> Some sk :: rest

     

       221
       221
       +
             | [] -> [Some sk]

     

       222
       222
       +
           )

     

       223
       223
       +
         end

     

       224
       224
       +
       

     

       225
       225
       +
       (** Remove simple key at current level *)

     

       226
       226
       +
       let remove_simple_key t =

     

       227
       227
       +
         match t.simple_keys with

     

       228
       228
       +
         | Some sk :: _rest when sk.sk_required ->

     

       229
       229
       +
             Error.raise_at sk.sk_position Expected_key

     

       230
       230
       +
         | _ :: rest -> t.simple_keys <- None :: rest

     

       231
       231
       +
         | [] -> ()

     

       232
       232
       +
       

     

       233
       233
       +
       (** Stale simple keys that span too many tokens *)

     

       234
       234
       +
       let stale_simple_keys t =

     

       235
       235
       +
         t.simple_keys <- List.map (fun sk_opt ->

     

       236
       236
       +
           match sk_opt with

     

       237
       237
       +
           | Some sk when sk.sk_possible &&

     

       238
       238
       +
                          (Input.position t.input).line > sk.sk_position.line &&

     

       239
       239
       +
                          t.flow_level = 0 ->

     

       240
       240
       +
               if sk.sk_required then

     

       241
       241
       +
                 Error.raise_at sk.sk_position Expected_key;

     

       242
       242
       +
               None

     

       243
       243
       +
           | _ -> sk_opt

     

       244
       244
       +
         ) t.simple_keys

     

       245
       245
       +
       

     

       246
       246
       +
       (** Read anchor or alias name *)

     

       247
       247
       +
       let scan_anchor_alias t =

     

       248
       248
       +
         let start = Input.mark t.input in

     

       249
       249
       +
         let buf = Buffer.create 16 in

     

       250
       250
       +
         (* Per YAML 1.2 spec: anchor names can contain any character that is NOT:

     

       251
       251
       +
            - Whitespace (space, tab, line breaks)

     

       252
       252
       +
            - Flow indicators: []{}

     

       253
       253
       +
            - Comma (,)

     

       254
       254
       +
            This matches the saphyr implementation: is_yaml_non_space && !is_flow *)

     

       255
       255
       +
         while

     

       256
       256
       +
           match Input.peek t.input with

     

       257
       257
       +
           | Some c when not (Input.is_whitespace c) &&

     

       258
       258
       +
                         not (Input.is_flow_indicator c) &&

     

       259
       259
       +
                         c <> '\x00' ->

     

       260
       260
       +
               Buffer.add_char buf c;

     

       261
       261
       +
               ignore (Input.next t.input);

     

       262
       262
       +
               true

     

       263
       263
       +
           | _ -> false

     

       264
       264
       +
         do () done;

     

       265
       265
       +
         let name = Buffer.contents buf in

     

       266
       266
       +
         if String.length name = 0 then

     

       267
       267
       +
           Error.raise_at start (Invalid_anchor "empty anchor name");

     

       268
       268
       +
         (name, Span.make ~start ~stop:(Input.mark t.input))

     

       269
       269
       +
       

     

       270
       270
       +
       (** Scan tag handle *)

     

       271
       271
       +
       let scan_tag_handle t =

     

       272
       272
       +
         let start = Input.mark t.input in

     

       273
       273
       +
         let buf = Buffer.create 16 in

     

       274
       274
       +
         (* Expect ! *)

     

       275
       275
       +
         (match Input.peek t.input with

     

       276
       276
       +
          | Some '!' ->

     

       277
       277
       +
              Buffer.add_char buf '!';

     

       278
       278
       +
              ignore (Input.next t.input)

     

       279
       279
       +
          | _ -> Error.raise_at start (Invalid_tag "expected '!'"));

     

       280
       280
       +
         (* Read word chars *)

     

       281
       281
       +
         while

     

       282
       282
       +
           match Input.peek t.input with

     

       283
       283
       +
           | Some c when Input.is_alnum c || c = '-' ->

     

       284
       284
       +
               Buffer.add_char buf c;

     

       285
       285
       +
               ignore (Input.next t.input);

     

       286
       286
       +
               true

     

       287
       287
       +
           | _ -> false

     

       288
       288
       +
         do () done;

     

       289
       289
       +
         (* Check for secondary ! *)

     

       290
       290
       +
         (match Input.peek t.input with

     

       291
       291
       +
          | Some '!' ->

     

       292
       292
       +
              Buffer.add_char buf '!';

     

       293
       293
       +
              ignore (Input.next t.input)

     

       294
       294
       +
          | _ -> ());

     

       295
       295
       +
         Buffer.contents buf

     

       296
       296
       +
       

     

       297
       297
       +
       (** Scan tag suffix (after handle) *)

     

       298
       298
       +
       let scan_tag_suffix t =

     

       299
       299
       +
         let is_hex_digit c =

     

       300
       300
       +
           (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f')

     

       301
       301
       +
         in

     

       302
       302
       +
         let hex_val c =

     

       303
       303
       +
           match c with

     

       304
       304
       +
           | '0'..'9' -> Char.code c - Char.code '0'

     

       305
       305
       +
           | 'A'..'F' -> Char.code c - Char.code 'A' + 10

     

       306
       306
       +
           | 'a'..'f' -> Char.code c - Char.code 'a' + 10

     

       307
       307
       +
           | _ -> 0

     

       308
       308
       +
         in

     

       309
       309
       +
         let buf = Buffer.create 32 in

     

       310
       310
       +
         while

     

       311
       311
       +
           match Input.peek t.input with

     

       312
       312
       +
           | Some '%' ->

     

       313
       313
       +
               (* Percent-encoded character *)

     

       314
       314
       +
               ignore (Input.next t.input);

     

       315
       315
       +
               (match Input.peek t.input, Input.peek_nth t.input 1 with

     

       316
       316
       +
                | Some c1, Some c2 when is_hex_digit c1 && is_hex_digit c2 ->

     

       317
       317
       +
                    ignore (Input.next t.input);

     

       318
       318
       +
                    ignore (Input.next t.input);

     

       319
       319
       +
                    let code = (hex_val c1) * 16 + (hex_val c2) in

     

       320
       320
       +
                    Buffer.add_char buf (Char.chr code);

     

       321
       321
       +
                    true

     

       322
       322
       +
                | _ ->

     

       323
       323
       +
                    (* Invalid percent encoding - keep the % *)

     

       324
       324
       +
                    Buffer.add_char buf '%';

     

       325
       325
       +
                    true)

     

       326
       326
       +
           | Some c when not (Input.is_whitespace c) &&

     

       327
       327
       +
                         not (Input.is_flow_indicator c) ->

     

       328
       328
       +
               Buffer.add_char buf c;

     

       329
       329
       +
               ignore (Input.next t.input);

     

       330
       330
       +
               true

     

       331
       331
       +
           | _ -> false

     

       332
       332
       +
         do () done;

     

       333
       333
       +
         Buffer.contents buf

     

       334
       334
       +
       

     

       335
       335
       +
       (** Scan a tag *)

     

       336
       336
       +
       let scan_tag t =

     

       337
       337
       +
         let start = Input.mark t.input in

     

       338
       338
       +
         ignore (Input.next t.input); (* consume ! *)

     

       339
       339
       +
         let handle, suffix =

     

       340
       340
       +
           match Input.peek t.input with

     

       341
       341
       +
           | Some '<' ->

     

       342
       342
       +
               (* Verbatim tag: !<...> - handle is empty, suffix is full URI *)

     

       343
       343
       +
               ignore (Input.next t.input);

     

       344
       344
       +
               let buf = Buffer.create 32 in

     

       345
       345
       +
               while

     

       346
       346
       +
                 match Input.peek t.input with

     

       347
       347
       +
                 | Some '>' -> false

     

       348
       348
       +
                 | Some c ->

     

       349
       349
       +
                     Buffer.add_char buf c;

     

       350
       350
       +
                     ignore (Input.next t.input);

     

       351
       351
       +
                     true

     

       352
       352
       +
                 | None -> Error.raise_at (Input.mark t.input) (Invalid_tag "unclosed verbatim tag")

     

       353
       353
       +
               do () done;

     

       354
       354
       +
               ignore (Input.next t.input); (* consume > *)

     

       355
       355
       +
               ("", Buffer.contents buf)

     

       356
       356
       +
           | Some c when Input.is_whitespace c || Input.is_flow_indicator c ->

     

       357
       357
       +
               (* Non-specific tag: ! *)

     

       358
       358
       +
               ("!", "")

     

       359
       359
       +
           | Some '!' ->

     

       360
       360
       +
               (* Secondary handle: !! *)

     

       361
       361
       +
               ignore (Input.next t.input); (* consume second ! *)

     

       362
       362
       +
               let suffix = scan_tag_suffix t in

     

       363
       363
       +
               ("!!", suffix)

     

       364
       364
       +
           | _ ->

     

       365
       365
       +
               (* Primary handle or just suffix: !foo or !e!foo *)

     

       366
       366
       +
               (* Read alphanumeric characters *)

     

       367
       367
       +
               let buf = Buffer.create 16 in

     

       368
       368
       +
               while

     

       369
       369
       +
                 match Input.peek t.input with

     

       370
       370
       +
                 | Some c when Input.is_alnum c || c = '-' ->

     

       371
       371
       +
                     Buffer.add_char buf c;

     

       372
       372
       +
                     ignore (Input.next t.input);

     

       373
       373
       +
                     true

     

       374
       374
       +
                 | _ -> false

     

       375
       375
       +
               do () done;

     

       376
       376
       +
               (* Check if next character is ! - if so, this is a named handle *)

     

       377
       377
       +
               (match Input.peek t.input with

     

       378
       378
       +
                | Some '!' ->

     

       379
       379
       +
                    (* Named handle like !e! *)

     

       380
       380
       +
                    ignore (Input.next t.input);

     

       381
       381
       +
                    let handle_name = Buffer.contents buf in

     

       382
       382
       +
                    let suffix = scan_tag_suffix t in

     

       383
       383
       +
                    ("!" ^ handle_name ^ "!", suffix)

     

       384
       384
       +
                | _ ->

     

       385
       385
       +
                    (* Just ! followed by suffix *)

     

       386
       386
       +
                    ("!", Buffer.contents buf ^ scan_tag_suffix t))

     

       387
       387
       +
         in

     

       388
       388
       +
         (* Validate that tag is followed by whitespace, break, or (in flow) flow indicator *)

     

       389
       389
       +
         (match Input.peek t.input with

     

       390
       390
       +
          | None -> ()  (* EOF is ok *)

     

       391
       391
       +
          | Some c when Input.is_whitespace c || Input.is_break c -> ()

     

       392
       392
       +
          | Some c when t.flow_level > 0 && Input.is_flow_indicator c -> ()

     

       393
       393
       +
          | _ -> Error.raise_at start (Invalid_tag "expected whitespace or line break after tag"));

     

       394
       394
       +
         let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       395
       395
       +
         (handle, suffix, span)

     

       396
       396
       +
       

     

       397
       397
       +
       (** Scan single-quoted scalar *)

     

       398
       398
       +
       let scan_single_quoted t =

     

       399
       399
       +
         let start = Input.mark t.input in

     

       400
       400
       +
         ignore (Input.next t.input); (* consume opening single-quote *)

     

       401
       401
       +
         let buf = Buffer.create 64 in

     

       402
       402
       +
         let whitespace = Buffer.create 16 in (* Track trailing whitespace *)

     

       403
       403
       +
       

     

       404
       404
       +
         let flush_whitespace () =

     

       405
       405
       +
           if Buffer.length whitespace > 0 then begin

     

       406
       406
       +
             Buffer.add_buffer buf whitespace;

     

       407
       407
       +
             Buffer.clear whitespace

     

       408
       408
       +
           end

     

       409
       409
       +
         in

     

       410
       410
       +
       

     

       411
       411
       +
         let rec loop () =

     

       412
       412
       +
           match Input.peek t.input with

     

       413
       413
       +
           | None -> Error.raise_at start Unclosed_single_quote

     

       414
       414
       +
           | Some '\'' ->

     

       415
       415
       +
               ignore (Input.next t.input);

     

       416
       416
       +
               (* Check for escaped quote ('') *)

     

       417
       417
       +
               (match Input.peek t.input with

     

       418
       418
       +
                | Some '\'' ->

     

       419
       419
       +
                    flush_whitespace ();

     

       420
       420
       +
                    Buffer.add_char buf '\'';

     

       421
       421
       +
                    ignore (Input.next t.input);

     

       422
       422
       +
                    loop ()

     

       423
       423
       +
                | _ ->

     

       424
       424
       +
                    (* End of string - flush any trailing whitespace *)

     

       425
       425
       +
                    flush_whitespace ())

     

       426
       426
       +
           | Some ' ' | Some '\t' ->

     

       427
       427
       +
               (* Track whitespace - don't add to buf yet *)

     

       428
       428
       +
               Buffer.add_char whitespace (Option.get (Input.peek t.input));

     

       429
       429
       +
               ignore (Input.next t.input);

     

       430
       430
       +
               loop ()

     

       431
       431
       +
           | Some '\n' | Some '\r' ->

     

       432
       432
       +
               (* Discard trailing whitespace before line break *)

     

       433
       433
       +
               Buffer.clear whitespace;

     

       434
       434
       +
               Input.consume_break t.input;

     

       435
       435
       +
               (* Skip leading whitespace on next line *)

     

       436
       436
       +
               while Input.next_is_blank t.input do

     

       437
       437
       +
                 ignore (Input.next t.input)

     

       438
       438
       +
               done;

     

       439
       439
       +
               (* Check for document boundary *)

     

       440
       440
       +
               if Input.at_document_boundary t.input then

     

       441
       441
       +
                 Error.raise_at start Unclosed_single_quote;

     

       442
       442
       +
               (* Check indentation: continuation must be > block indent (QB6E, DK95) *)

     

       443
       443
       +
               let col = column t in

     

       444
       444
       +
               let indent = current_indent t in

     

       445
       445
       +
               if not (Input.is_eof t.input) && not (Input.next_is_break t.input) && col <= indent && indent >= 0 then

     

       446
       446
       +
                 Error.raise_at (Input.mark t.input) (Invalid_quoted_scalar_indentation "invalid indentation in quoted scalar");

     

       447
       447
       +
               (* Count empty lines (consecutive line breaks) *)

     

       448
       448
       +
               let empty_lines = ref 0 in

     

       449
       449
       +
               while Input.next_is_break t.input do

     

       450
       450
       +
                 incr empty_lines;

     

       451
       451
       +
                 Input.consume_break t.input;

     

       452
       452
       +
                 while Input.next_is_blank t.input do

     

       453
       453
       +
                   ignore (Input.next t.input)

     

       454
       454
       +
                 done;

     

       455
       455
       +
                 if Input.at_document_boundary t.input then

     

       456
       456
       +
                   Error.raise_at start Unclosed_single_quote;

     

       457
       457
       +
                 (* Check indentation after each empty line too *)

     

       458
       458
       +
                 let col = column t in

     

       459
       459
       +
                 let indent = current_indent t in

     

       460
       460
       +
                 if not (Input.is_eof t.input) && not (Input.next_is_break t.input) && col <= indent && indent >= 0 then

     

       461
       461
       +
                   Error.raise_at (Input.mark t.input) (Invalid_quoted_scalar_indentation "invalid indentation in quoted scalar")

     

       462
       462
       +
               done;

     

       463
       463
       +
               (* Apply folding rules *)

     

       464
       464
       +
               if !empty_lines > 0 then begin

     

       465
       465
       +
                 (* Empty lines: preserve as newlines *)

     

       466
       466
       +
                 for _ = 1 to !empty_lines do

     

       467
       467
       +
                   Buffer.add_char buf '\n'

     

       468
       468
       +
                 done

     

       469
       469
       +
               end else

     

       470
       470
       +
                 (* Single break: fold to space (even at start of string) *)

     

       471
       471
       +
                 Buffer.add_char buf ' ';

     

       472
       472
       +
               loop ()

     

       473
       473
       +
           | Some c ->

     

       474
       474
       +
               flush_whitespace ();

     

       475
       475
       +
               Buffer.add_char buf c;

     

       476
       476
       +
               ignore (Input.next t.input);

     

       477
       477
       +
               loop ()

     

       478
       478
       +
         in

     

       479
       479
       +
         loop ();

     

       480
       480
       +
         let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       481
       481
       +
         (Buffer.contents buf, span)

     

       482
       482
       +
       

     

       483
       483
       +
       (** Decode hex escape of given length *)

     

       484
       484
       +
       let decode_hex t len =

     

       485
       485
       +
         let start = Input.mark t.input in

     

       486
       486
       +
         let buf = Buffer.create len in

     

       487
       487
       +
         for _ = 1 to len do

     

       488
       488
       +
           match Input.peek t.input with

     

       489
       489
       +
           | Some c when Input.is_hex c ->

     

       490
       490
       +
               Buffer.add_char buf c;

     

       491
       491
       +
               ignore (Input.next t.input)

     

       492
       492
       +
           | _ ->

     

       493
       493
       +
               Error.raise_at start (Invalid_hex_escape (Buffer.contents buf))

     

       494
       494
       +
         done;

     

       495
       495
       +
         let code = int_of_string ("0x" ^ Buffer.contents buf) in

     

       496
       496
       +
         if code <= 0x7F then

     

       497
       497
       +
           String.make 1 (Char.chr code)

     

       498
       498
       +
         else if code <= 0x7FF then

     

       499
       499
       +
           let b1 = 0xC0 lor (code lsr 6) in

     

       500
       500
       +
           let b2 = 0x80 lor (code land 0x3F) in

     

       501
       501
       +
           String.init 2 (fun i -> Char.chr (if i = 0 then b1 else b2))

     

       502
       502
       +
         else if code <= 0xFFFF then

     

       503
       503
       +
           let b1 = 0xE0 lor (code lsr 12) in

     

       504
       504
       +
           let b2 = 0x80 lor ((code lsr 6) land 0x3F) in

     

       505
       505
       +
           let b3 = 0x80 lor (code land 0x3F) in

     

       506
       506
       +
           String.init 3 (fun i -> Char.chr (match i with 0 -> b1 | 1 -> b2 | _ -> b3))

     

       507
       507
       +
         else

     

       508
       508
       +
           let b1 = 0xF0 lor (code lsr 18) in

     

       509
       509
       +
           let b2 = 0x80 lor ((code lsr 12) land 0x3F) in

     

       510
       510
       +
           let b3 = 0x80 lor ((code lsr 6) land 0x3F) in

     

       511
       511
       +
           let b4 = 0x80 lor (code land 0x3F) in

     

       512
       512
       +
           String.init 4 (fun i -> Char.chr (match i with 0 -> b1 | 1 -> b2 | 2 -> b3 | _ -> b4))

     

       513
       513
       +
       

     

       514
       514
       +
       (** Scan double-quoted scalar *)

     

       515
       515
       +
       let scan_double_quoted t =

     

       516
       516
       +
         let start = Input.mark t.input in

     

       517
       517
       +
         ignore (Input.next t.input); (* consume opening double-quote *)

     

       518
       518
       +
         let buf = Buffer.create 64 in

     

       519
       519
       +
         let whitespace = Buffer.create 16 in  (* Track pending whitespace *)

     

       520
       520
       +
       

     

       521
       521
       +
         let flush_whitespace () =

     

       522
       522
       +
           if Buffer.length whitespace > 0 then begin

     

       523
       523
       +
             Buffer.add_buffer buf whitespace;

     

       524
       524
       +
             Buffer.clear whitespace

     

       525
       525
       +
           end

     

       526
       526
       +
         in

     

       527
       527
       +
       

     

       528
       528
       +
         let rec loop () =

     

       529
       529
       +
           match Input.peek t.input with

     

       530
       530
       +
           | None -> Error.raise_at start Unclosed_double_quote

     

       531
       531
       +
           | Some '"' ->

     

       532
       532
       +
               (* Flush trailing whitespace before closing quote to preserve it *)

     

       533
       533
       +
               flush_whitespace ();

     

       534
       534
       +
               ignore (Input.next t.input)

     

       535
       535
       +
           | Some ' ' | Some '\t' as c_opt ->

     

       536
       536
       +
               (* Track whitespace - don't add to buf yet *)

     

       537
       537
       +
               let c = match c_opt with Some c -> c | None -> assert false in

     

       538
       538
       +
               Buffer.add_char whitespace c;

     

       539
       539
       +
               ignore (Input.next t.input);

     

       540
       540
       +
               loop ()

     

       541
       541
       +
           | Some '\\' ->

     

       542
       542
       +
               (* Escape sequence - this is non-whitespace content *)

     

       543
       543
       +
               flush_whitespace ();  (* Commit any pending whitespace *)

     

       544
       544
       +
               ignore (Input.next t.input);

     

       545
       545
       +
               (match Input.peek t.input with

     

       546
       546
       +
                | None -> Error.raise_at start (Invalid_escape_sequence "\\<EOF>")

     

       547
       547
       +
                | Some '0' -> Buffer.add_char buf '\x00'; ignore (Input.next t.input)

     

       548
       548
       +
                | Some 'a' -> Buffer.add_char buf '\x07'; ignore (Input.next t.input)

     

       549
       549
       +
                | Some 'b' -> Buffer.add_char buf '\x08'; ignore (Input.next t.input)

     

       550
       550
       +
                | Some 't' | Some '\t' -> Buffer.add_char buf '\t'; ignore (Input.next t.input)

     

       551
       551
       +
                | Some 'n' -> Buffer.add_char buf '\n'; ignore (Input.next t.input)

     

       552
       552
       +
                | Some 'v' -> Buffer.add_char buf '\x0B'; ignore (Input.next t.input)

     

       553
       553
       +
                | Some 'f' -> Buffer.add_char buf '\x0C'; ignore (Input.next t.input)

     

       554
       554
       +
                | Some 'r' -> Buffer.add_char buf '\r'; ignore (Input.next t.input)

     

       555
       555
       +
                | Some 'e' -> Buffer.add_char buf '\x1B'; ignore (Input.next t.input)

     

       556
       556
       +
                | Some ' ' -> Buffer.add_char buf ' '; ignore (Input.next t.input)

     

       557
       557
       +
                | Some '"' -> Buffer.add_char buf '"'; ignore (Input.next t.input)

     

       558
       558
       +
                | Some '/' -> Buffer.add_char buf '/'; ignore (Input.next t.input)

     

       559
       559
       +
                | Some '\\' -> Buffer.add_char buf '\\'; ignore (Input.next t.input)

     

       560
       560
       +
                | Some 'N' -> Buffer.add_string buf "\xC2\x85"; ignore (Input.next t.input) (* NEL *)

     

       561
       561
       +
                | Some '_' -> Buffer.add_string buf "\xC2\xA0"; ignore (Input.next t.input) (* NBSP *)

     

       562
       562
       +
                | Some 'L' -> Buffer.add_string buf "\xE2\x80\xA8"; ignore (Input.next t.input) (* LS *)

     

       563
       563
       +
                | Some 'P' -> Buffer.add_string buf "\xE2\x80\xA9"; ignore (Input.next t.input) (* PS *)

     

       564
       564
       +
                | Some 'x' ->

     

       565
       565
       +
                    ignore (Input.next t.input);

     

       566
       566
       +
                    Buffer.add_string buf (decode_hex t 2)

     

       567
       567
       +
                | Some 'u' ->

     

       568
       568
       +
                    ignore (Input.next t.input);

     

       569
       569
       +
                    Buffer.add_string buf (decode_hex t 4)

     

       570
       570
       +
                | Some 'U' ->

     

       571
       571
       +
                    ignore (Input.next t.input);

     

       572
       572
       +
                    Buffer.add_string buf (decode_hex t 8)

     

       573
       573
       +
                | Some '\n' | Some '\r' ->

     

       574
       574
       +
                    (* Line continuation escape *)

     

       575
       575
       +
                    Input.consume_break t.input;

     

       576
       576
       +
                    while Input.next_is_blank t.input do

     

       577
       577
       +
                      ignore (Input.next t.input)

     

       578
       578
       +
                    done

     

       579
       579
       +
                | Some c ->

     

       580
       580
       +
                    Error.raise_at (Input.mark t.input)

     

       581
       581
       +
                      (Invalid_escape_sequence (Printf.sprintf "\\%c" c)));

     

       582
       582
       +
               loop ()

     

       583
       583
       +
           | Some '\n' | Some '\r' ->

     

       584
       584
       +
               (* Line break: discard any pending trailing whitespace *)

     

       585
       585
       +
               Buffer.clear whitespace;

     

       586
       586
       +
               Input.consume_break t.input;

     

       587
       587
       +
               (* Count consecutive line breaks (empty lines) *)

     

       588
       588
       +
               let empty_lines = ref 0 in

     

       589
       589
       +
               let continue = ref true in

     

       590
       590
       +
               let started_with_tab = ref false in

     

       591
       591
       +
               while !continue do

     

       592
       592
       +
                 (* Track if we start with a tab (for DK95/01 check) *)

     

       593
       593
       +
                 if Input.next_is (( = ) '\t') t.input then started_with_tab := true;

     

       594
       594
       +
                 (* Skip blanks (spaces/tabs) on the line *)

     

       595
       595
       +
                 while Input.next_is_blank t.input do

     

       596
       596
       +
                   ignore (Input.next t.input)

     

       597
       597
       +
                 done;

     

       598
       598
       +
                 (* Check if we hit another line break (empty line) *)

     

       599
       599
       +
                 if Input.next_is_break t.input then begin

     

       600
       600
       +
                   Input.consume_break t.input;

     

       601
       601
       +
                   incr empty_lines;

     

       602
       602
       +
                   started_with_tab := false  (* Reset for next line *)

     

       603
       603
       +
                 end else

     

       604
       604
       +
                   continue := false

     

       605
       605
       +
               done;

     

       606
       606
       +
               (* Check for document boundary - this terminates the quoted string *)

     

       607
       607
       +
               if Input.at_document_boundary t.input then

     

       608
       608
       +
                 Error.raise_at start Unclosed_double_quote;

     

       609
       609
       +
               (* Check indentation: continuation must be > block indent (QB6E, DK95)

     

       610
       610
       +
                  Note: must be strictly greater than block indent, not just equal *)

     

       611
       611
       +
               let col = column t in

     

       612
       612
       +
               let indent = current_indent t in

     

       613
       613
       +
               let start_col = start.column in

     

       614
       614
       +
               (* DK95/01: if continuation started with tabs and column < start column, error *)

     

       615
       615
       +
               if not (Input.is_eof t.input) && !started_with_tab && col < start_col then

     

       616
       616
       +
                 Error.raise_at (Input.mark t.input) (Invalid_quoted_scalar_indentation "invalid indentation in quoted scalar");

     

       617
       617
       +
               if not (Input.is_eof t.input) && col <= indent && indent >= 0 then

     

       618
       618
       +
                 Error.raise_at (Input.mark t.input) (Invalid_quoted_scalar_indentation "invalid indentation in quoted scalar");

     

       619
       619
       +
               (* Per YAML spec: single break = space, break + empty lines = newlines *)

     

       620
       620
       +
               if !empty_lines > 0 then begin

     

       621
       621
       +
                 (* Empty lines: output N newlines where N = number of empty lines *)

     

       622
       622
       +
                 for _ = 1 to !empty_lines do

     

       623
       623
       +
                   Buffer.add_char buf '\n'

     

       624
       624
       +
                 done

     

       625
       625
       +
               end else

     

       626
       626
       +
                 (* Single break folds to space *)

     

       627
       627
       +
                 Buffer.add_char buf ' ';

     

       628
       628
       +
               loop ()

     

       629
       629
       +
           | Some c ->

     

       630
       630
       +
               (* Non-whitespace character *)

     

       631
       631
       +
               flush_whitespace ();  (* Commit any pending whitespace *)

     

       632
       632
       +
               Buffer.add_char buf c;

     

       633
       633
       +
               ignore (Input.next t.input);

     

       634
       634
       +
               loop ()

     

       635
       635
       +
         in

     

       636
       636
       +
         loop ();

     

       637
       637
       +
         let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       638
       638
       +
         (Buffer.contents buf, span)

     

       639
       639
       +
       

     

       640
       640
       +
       (** Check if character can appear in plain scalar at this position *)

     

       641
       641
       +
       let can_continue_plain t c ~in_flow =

     

       642
       642
       +
         match c with

     

       643
       643
       +
         | ':' ->

     

       644
       644
       +
             (* : is OK if not followed by whitespace or flow indicator *)

     

       645
       645
       +
             (match Input.peek_nth t.input 1 with

     

       646
       646
       +
              | None -> true

     

       647
       647
       +
              | Some c2 when Input.is_whitespace c2 -> false

     

       648
       648
       +
              | Some c2 when in_flow && Input.is_flow_indicator c2 -> false

     

       649
       649
       +
              | _ -> true)

     

       650
       650
       +
         | '#' ->

     

       651
       651
       +
             (* # is a comment indicator only if preceded by whitespace *)

     

       652
       652
       +
             (* Check the previous character to determine if this is a comment *)

     

       653
       653
       +
             (match Input.peek_back t.input with

     

       654
       654
       +
              | None -> true  (* At start - can't be comment indicator, allow it *)

     

       655
       655
       +
              | Some c when Input.is_whitespace c -> false  (* Preceded by whitespace - comment *)

     

       656
       656
       +
              | Some c when Input.is_break c -> false  (* At start of line - comment *)

     

       657
       657
       +
              | _ -> true)  (* Not preceded by whitespace - part of scalar *)

     

       658
       658
       +
         | c when in_flow && Input.is_flow_indicator c -> false

     

       659
       659
       +
         | _ when Input.is_break c -> false

     

       660
       660
       +
         | _ -> true

     

       661
       661
       +
       

     

       662
       662
       +
       (** Scan plain scalar *)

     

       663
       663
       +
       let scan_plain_scalar t =

     

       664
       664
       +
         let start = Input.mark t.input in

     

       665
       665
       +
         let in_flow = t.flow_level > 0 in

     

       666
       666
       +
         let indent = current_indent t in

     

       667
       667
       +
         (* In flow context, scalars must be indented more than the current block indent.

     

       668
       668
       +
            This ensures that content at block indent or less ends the flow context. *)

     

       669
       669
       +
         if in_flow && (column t - 1) < indent then

     

       670
       670
       +
           Error.raise_at start Invalid_flow_indentation;

     

       671
       671
       +
         let buf = Buffer.create 64 in

     

       672
       672
       +
         let spaces = Buffer.create 16 in

     

       673
       673
       +
         let whitespace = Buffer.create 16 in  (* Track whitespace within a line *)

     

       674
       674
       +
         let leading_blanks = ref false in

     

       675
       675
       +
       

     

       676
       676
       +
         let rec scan_line () =

     

       677
       677
       +
           match Input.peek t.input with

     

       678
       678
       +
           | None -> ()

     

       679
       679
       +
           | Some c when Input.is_blank c && can_continue_plain t c ~in_flow ->

     

       680
       680
       +
               (* Blank character within a line - save to whitespace buffer *)

     

       681
       681
       +
               Buffer.add_char whitespace c;

     

       682
       682
       +
               ignore (Input.next t.input);

     

       683
       683
       +
               scan_line ()

     

       684
       684
       +
           | Some c when can_continue_plain t c ~in_flow ->

     

       685
       685
       +
               (* Non-blank character - process any pending breaks/whitespace first *)

     

       686
       686
       +
               begin

     

       687
       687
       +
                 if Buffer.length spaces > 0 then begin

     

       688
       688
       +
                   if !leading_blanks then begin

     

       689
       689
       +
                     (* Fold line break *)

     

       690
       690
       +
                     if Buffer.contents spaces = "\n" then

     

       691
       691
       +
                       Buffer.add_char buf ' '

     

       692
       692
       +
                     else begin

     

       693
       693
       +
                       (* Multiple breaks - preserve all but first *)

     

       694
       694
       +
                       let s = Buffer.contents spaces in

     

       695
       695
       +
                       Buffer.add_substring buf s 1 (String.length s - 1)

     

       696
       696
       +
                     end

     

       697
       697
       +
                   end else

     

       698
       698
       +
                     Buffer.add_buffer buf spaces;

     

       699
       699
       +
                   Buffer.clear spaces

     

       700
       700
       +
                 end;

     

       701
       701
       +
                 (* Add any pending whitespace from within the line *)

     

       702
       702
       +
                 if Buffer.length whitespace > 0 then begin

     

       703
       703
       +
                   Buffer.add_buffer buf whitespace;

     

       704
       704
       +
                   Buffer.clear whitespace

     

       705
       705
       +
                 end;

     

       706
       706
       +
                 (* Add the character *)

     

       707
       707
       +
                 Buffer.add_char buf c;

     

       708
       708
       +
                 ignore (Input.next t.input);

     

       709
       709
       +
                 leading_blanks := false;

     

       710
       710
       +
                 scan_line ()

     

       711
       711
       +
               end

     

       712
       712
       +
           | _ -> ()

     

       713
       713
       +
         in

     

       714
       714
       +
       

     

       715
       715
       +
         let rec scan_lines () =

     

       716
       716
       +
           scan_line ();

     

       717
       717
       +
           (* Check for line continuation *)

     

       718
       718
       +
           if Input.next_is_break t.input then begin

     

       719
       719
       +
             (* Discard any trailing whitespace from the current line *)

     

       720
       720
       +
             Buffer.clear whitespace;

     

       721
       721
       +
             (* Save the line break *)

     

       722
       722
       +
             if !leading_blanks then begin

     

       723
       723
       +
               (* We already had a break - this is an additional break (empty line) *)

     

       724
       724
       +
               Buffer.add_char spaces '\n'

     

       725
       725
       +
             end else begin

     

       726
       726
       +
               (* First line break *)

     

       727
       727
       +
               Buffer.clear spaces;

     

       728
       728
       +
               Buffer.add_char spaces '\n';

     

       729
       729
       +
               leading_blanks := true

     

       730
       730
       +
             end;

     

       731
       731
       +
             Input.consume_break t.input;

     

       732
       732
       +
             (* Note: We do NOT set allow_simple_key here during plain scalar scanning.

     

       733
       733
       +
                Setting it here would incorrectly allow ':' that appears on a continuation

     

       734
       734
       +
                line to become a mapping indicator. The flag will be set properly after

     

       735
       735
       +
                the scalar ends and skip_to_next_token processes line breaks. *)

     

       736
       736
       +
             (* Skip leading blanks on the next line *)

     

       737
       737
       +
             while Input.next_is_blank t.input do

     

       738
       738
       +
               ignore (Input.next t.input)

     

       739
       739
       +
             done;

     

       740
       740
       +
             let col = (Input.position t.input).column in

     

       741
       741
       +
             (* Check indentation - stop if we're at or before the containing block's indent *)

     

       742
       742
       +
             (* However, allow empty lines (line breaks) to continue even if dedented *)

     

       743
       743
       +
             if Input.next_is_break t.input then

     

       744
       744
       +
               scan_lines () (* Empty line - continue *)

     

       745
       745
       +
             else if not in_flow && col <= indent then

     

       746
       746
       +
               () (* Stop - dedented or at parent level in block context *)

     

       747
       747
       +
             else if Input.at_document_boundary t.input then

     

       748
       748
       +
               () (* Stop - document boundary *)

     

       749
       749
       +
             else

     

       750
       750
       +
               scan_lines ()

     

       751
       751
       +
           end

     

       752
       752
       +
         in

     

       753
       753
       +
       

     

       754
       754
       +
         scan_lines ();

     

       755
       755
       +
         let value = Buffer.contents buf in

     

       756
       756
       +
         (* Trim trailing whitespace (spaces and tabs) *)

     

       757
       757
       +
         let value =

     

       758
       758
       +
           let len = String.length value in

     

       759
       759
       +
           let rec find_end i =

     

       760
       760
       +
             if i < 0 then 0

     

       761
       761
       +
             else match value.[i] with

     

       762
       762
       +
               | ' ' | '\t' -> find_end (i - 1)

     

       763
       763
       +
               | _ -> i + 1

     

       764
       764
       +
           in

     

       765
       765
       +
           let end_pos = find_end (len - 1) in

     

       766
       766
       +
           String.sub value 0 end_pos

     

       767
       767
       +
         in

     

       768
       768
       +
         let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       769
       769
       +
         (* Return value, span, and whether we ended with leading blanks (crossed a line break) *)

     

       770
       770
       +
         (value, span, !leading_blanks)

     

       771
       771
       +
       

     

       772
       772
       +
       (** Scan block scalar (literal | or folded >) *)

     

       773
       773
       +
       let scan_block_scalar t literal =

     

       774
       774
       +
         let start = Input.mark t.input in

     

       775
       775
       +
         ignore (Input.next t.input); (* consume | or > *)

     

       776
       776
       +
       

     

       777
       777
       +
         (* Parse header: optional indentation indicator and chomping *)

     

       778
       778
       +
         let explicit_indent = ref None in

     

       779
       779
       +
         let chomping = ref Chomping.Clip in

     

       780
       780
       +
       

     

       781
       781
       +
         (* First character of header *)

     

       782
       782
       +
         (match Input.peek t.input with

     

       783
       783
       +
          | Some c when Input.is_digit c && c <> '0' ->

     

       784
       784
       +
              explicit_indent := Some (Char.code c - Char.code '0');

     

       785
       785
       +
              ignore (Input.next t.input)

     

       786
       786
       +
          | Some '-' -> chomping := Chomping.Strip; ignore (Input.next t.input)

     

       787
       787
       +
          | Some '+' -> chomping := Chomping.Keep; ignore (Input.next t.input)

     

       788
       788
       +
          | _ -> ());

     

       789
       789
       +
       

     

       790
       790
       +
         (* Second character of header *)

     

       791
       791
       +
         (match Input.peek t.input with

     

       792
       792
       +
          | Some c when Input.is_digit c && c <> '0' && !explicit_indent = None ->

     

       793
       793
       +
              explicit_indent := Some (Char.code c - Char.code '0');

     

       794
       794
       +
              ignore (Input.next t.input)

     

       795
       795
       +
          | Some '-' when !chomping = Chomping.Clip ->

     

       796
       796
       +
              chomping := Chomping.Strip; ignore (Input.next t.input)

     

       797
       797
       +
          | Some '+' when !chomping = Chomping.Clip ->

     

       798
       798
       +
              chomping := Chomping.Keep; ignore (Input.next t.input)

     

       799
       799
       +
          | _ -> ());

     

       800
       800
       +
       

     

       801
       801
       +
         (* Skip whitespace and optional comment *)

     

       802
       802
       +
         skip_whitespace_and_comment t;

     

       803
       803
       +
       

     

       804
       804
       +
         (* Consume line break *)

     

       805
       805
       +
         if Input.next_is_break t.input then

     

       806
       806
       +
           Input.consume_break t.input

     

       807
       807
       +
         else if not (Input.is_eof t.input) then

     

       808
       808
       +
           Error.raise_at (Input.mark t.input)

     

       809
       809
       +
             (Invalid_block_scalar_header "expected newline after header");

     

       810
       810
       +
       

     

       811
       811
       +
         let base_indent = current_indent t in

     

       812
       812
       +
         (* base_indent is the indent level from the stack, -1 if empty.

     

       813
       813
       +
            It's used directly for comparisons in implicit indent case. *)

     

       814
       814
       +
         let content_indent = ref (

     

       815
       815
       +
           match !explicit_indent with

     

       816
       816
       +
           | Some n ->

     

       817
       817
       +
               (* Explicit indent: base_indent is 1-indexed column, convert to 0-indexed.

     

       818
       818
       +
                  content_indent = (base_indent - 1) + n, but at least n for document level. *)

     

       819
       819
       +
               let base_level = max 0 (base_indent - 1) in

     

       820
       820
       +
               base_level + n

     

       821
       821
       +
           | None -> 0  (* Will be determined by first non-empty line *)

     

       822
       822
       +
         ) in

     

       823
       823
       +
       

     

       824
       824
       +
         let buf = Buffer.create 256 in

     

       825
       825
       +
         let trailing_breaks = Buffer.create 16 in

     

       826
       826
       +
         let leading_blank = ref false in  (* Was the previous line "more indented"? *)

     

       827
       827
       +
         let max_empty_line_indent = ref 0 in  (* Track max indent of empty lines before first content *)

     

       828
       828
       +
       

     

       829
       829
       +
         (* Skip to content indentation, skipping empty lines.

     

       830
       830
       +
            Returns the number of spaces actually skipped (important for detecting dedentation). *)

     

       831
       831
       +
         let rec skip_to_content_indent () =

     

       832
       832
       +
           if !content_indent > 0 then begin

     

       833
       833
       +
             (* Explicit indent - skip up to content_indent spaces *)

     

       834
       834
       +
             let spaces_skipped = ref 0 in

     

       835
       835
       +
             while !spaces_skipped < !content_indent && Input.next_is (( = ) ' ') t.input do

     

       836
       836
       +
               incr spaces_skipped;

     

       837
       837
       +
               ignore (Input.next t.input)

     

       838
       838
       +
             done;

     

       839
       839
       +
       

     

       840
       840
       +
             (* Check if this line is empty (only spaces/tabs until break/eof) *)

     

       841
       841
       +
             if Input.next_is_break t.input then begin

     

       842
       842
       +
               (* Empty line - record the break and continue *)

     

       843
       843
       +
               Buffer.add_char trailing_breaks '\n';

     

       844
       844
       +
               Input.consume_break t.input;

     

       845
       845
       +
               skip_to_content_indent ()

     

       846
       846
       +
             end else if !spaces_skipped < !content_indent then begin

     

       847
       847
       +
               (* Line starts with fewer spaces than content_indent - dedented *)

     

       848
       848
       +
               !spaces_skipped

     

       849
       849
       +
             end else if Input.next_is_blank t.input then begin

     

       850
       850
       +
               (* Line has spaces/tabs beyond content_indent - could be whitespace content or empty line.

     

       851
       851
       +
                  For literal scalars, whitespace-only lines ARE content (not empty).

     

       852
       852
       +
                  For folded scalars, whitespace-only lines that are "more indented" are preserved. *)

     

       853
       853
       +
               if literal then

     

       854
       854
       +
                 (* Literal: whitespace beyond content_indent is content, let read_lines handle it *)

     

       855
       855
       +
                 !content_indent

     

       856
       856
       +
               else begin

     

       857
       857
       +
                 (* Folded: check if rest is only blanks *)

     

       858
       858
       +
                 let idx = ref 0 in

     

       859
       859
       +
                 while match Input.peek_nth t.input !idx with

     

       860
       860
       +
                       | Some c when Input.is_blank c -> incr idx; true

     

       861
       861
       +
                       | _ -> false

     

       862
       862
       +
                 do () done;

     

       863
       863
       +
                 match Input.peek_nth t.input (!idx) with

     

       864
       864
       +
                 | None | Some '\n' | Some '\r' ->

     

       865
       865
       +
                     (* Empty/whitespace-only line in folded - skip spaces *)

     

       866
       866
       +
                     while Input.next_is_blank t.input do

     

       867
       867
       +
                       ignore (Input.next t.input)

     

       868
       868
       +
                     done;

     

       869
       869
       +
                     Buffer.add_char trailing_breaks '\n';

     

       870
       870
       +
                     Input.consume_break t.input;

     

       871
       871
       +
                     skip_to_content_indent ()

     

       872
       872
       +
                 | _ ->

     

       873
       873
       +
                     (* Has non-whitespace content *)

     

       874
       874
       +
                     !content_indent

     

       875
       875
       +
               end

     

       876
       876
       +
             end else

     

       877
       877
       +
               !content_indent

     

       878
       878
       +
           end else begin

     

       879
       879
       +
             (* Implicit indent - skip empty lines without consuming spaces.

     

       880
       880
       +
                Note: Only SPACES count as indentation. Tabs are content, not indentation.

     

       881
       881
       +
                So we only check for spaces when determining if a line is "empty". *)

     

       882
       882
       +
             if Input.next_is_break t.input then begin

     

       883
       883
       +
               Buffer.add_char trailing_breaks '\n';

     

       884
       884
       +
               Input.consume_break t.input;

     

       885
       885
       +
               skip_to_content_indent ()

     

       886
       886
       +
             end else if Input.next_is (( = ) ' ') t.input then begin

     

       887
       887
       +
               (* Check if line is empty (only spaces before break) *)

     

       888
       888
       +
               let idx = ref 0 in

     

       889
       889
       +
               while match Input.peek_nth t.input !idx with

     

       890
       890
       +
                     | Some ' ' -> incr idx; true

     

       891
       891
       +
                     | _ -> false

     

       892
       892
       +
               do () done;

     

       893
       893
       +
               match Input.peek_nth t.input (!idx) with

     

       894
       894
       +
               | None | Some '\n' | Some '\r' ->

     

       895
       895
       +
                   (* Line has only spaces - empty line *)

     

       896
       896
       +
                   (* Track max indent of empty lines for later validation *)

     

       897
       897
       +
                   if !idx > !max_empty_line_indent then

     

       898
       898
       +
                     max_empty_line_indent := !idx;

     

       899
       899
       +
                   while Input.next_is (( = ) ' ') t.input do

     

       900
       900
       +
                     ignore (Input.next t.input)

     

       901
       901
       +
                   done;

     

       902
       902
       +
                   Buffer.add_char trailing_breaks '\n';

     

       903
       903
       +
                   Input.consume_break t.input;

     

       904
       904
       +
                   skip_to_content_indent ()

     

       905
       905
       +
               | _ ->

     

       906
       906
       +
                   (* Has content (including tabs which are content, not indentation) *)

     

       907
       907
       +
                   0

     

       908
       908
       +
             end else if Input.next_is (( = ) '\t') t.input then begin

     

       909
       909
       +
               (* Tab at start of line in implicit indent mode - this is an error (Y79Y)

     

       910
       910
       +
                  because tabs cannot be used as indentation in YAML *)

     

       911
       911
       +
               Error.raise_at (Input.mark t.input) Tab_in_indentation

     

       912
       912
       +
             end else

     

       913
       913
       +
               (* Not at break or space - other content character *)

     

       914
       914
       +
               0

     

       915
       915
       +
           end

     

       916
       916
       +
         in

     

       917
       917
       +
       

     

       918
       918
       +
         (* Read content *)

     

       919
       919
       +
         let rec read_lines () =

     

       920
       920
       +
           let spaces_skipped = skip_to_content_indent () in

     

       921
       921
       +
       

     

       922
       922
       +
           (* Check if we're at content *)

     

       923
       923
       +
           if Input.is_eof t.input then ()

     

       924
       924
       +
           else if Input.at_document_boundary t.input then ()

     

       925
       925
       +
           else begin

     

       926
       926
       +
             (* Count additional leading spaces beyond what was skipped *)

     

       927
       927
       +
             let extra_spaces = ref 0 in

     

       928
       928
       +
             while Input.next_is (( = ) ' ') t.input do

     

       929
       929
       +
               incr extra_spaces;

     

       930
       930
       +
               ignore (Input.next t.input)

     

       931
       931
       +
             done;

     

       932
       932
       +
       

     

       933
       933
       +
             (* Calculate actual line indentation *)

     

       934
       934
       +
             let line_indent = spaces_skipped + !extra_spaces in

     

       935
       935
       +
       

     

       936
       936
       +
             (* Determine content indent from first content line (implicit case) *)

     

       937
       937
       +
             let first_line = !content_indent = 0 in

     

       938
       938
       +
             (* base_indent is 1-indexed column, convert to 0-indexed for comparison with line_indent.

     

       939
       939
       +
                If base_indent = -1 (empty stack), then base_level = -1 means col 0 is valid. *)

     

       940
       940
       +
             let base_level = base_indent - 1 in

     

       941
       941
       +
             let should_process =

     

       942
       942
       +
               if !content_indent = 0 then begin

     

       943
       943
       +
                 (* For implicit indent, content must be more indented than base_level. *)

     

       944
       944
       +
                 if line_indent <= base_level then

     

       945
       945
       +
                   false  (* No content - first line not indented enough *)

     

       946
       946
       +
                 else begin

     

       947
       947
       +
                   (* Validate: first content line must be indented at least as much as

     

       948
       948
       +
                      the maximum indent seen on empty lines before it (5LLU, S98Z, W9L4) *)

     

       949
       949
       +
                   if line_indent < !max_empty_line_indent && line_indent > base_level then

     

       950
       950
       +
                     Error.raise_at (Input.mark t.input)

     

       951
       951
       +
                       (Invalid_block_scalar_header "wrongly indented line in block scalar");

     

       952
       952
       +
                   content_indent := line_indent;

     

       953
       953
       +
                   true

     

       954
       954
       +
                 end

     

       955
       955
       +
               end else if line_indent < !content_indent then

     

       956
       956
       +
                 false  (* Dedented - done with content *)

     

       957
       957
       +
               else

     

       958
       958
       +
                 true

     

       959
       959
       +
             in

     

       960
       960
       +
       

     

       961
       961
       +
             if should_process then begin

     

       962
       962
       +
               (* Check if current line is "more indented" (has extra indent or starts with whitespace).

     

       963
       963
       +
                  For folded scalars, lines that start with any whitespace (space or tab) after the

     

       964
       964
       +
                  content indentation are "more indented" and preserve breaks.

     

       965
       965
       +
                  Note: we check Input.next_is_blank BEFORE reading content to see if content starts with whitespace. *)

     

       966
       966
       +
               let trailing_blank = line_indent > !content_indent || Input.next_is_blank t.input in

     

       967
       967
       +
       

     

       968
       968
       +
               (* Add trailing breaks to buffer *)

     

       969
       969
       +
               if Buffer.length buf > 0 then begin

     

       970
       970
       +
                 if Buffer.length trailing_breaks > 0 then begin

     

       971
       971
       +
                   if literal then

     

       972
       972
       +
                     Buffer.add_buffer buf trailing_breaks

     

       973
       973
       +
                   else begin

     

       974
       974
       +
                     (* Folded scalar: fold only if both previous and current lines are not more-indented *)

     

       975
       975
       +
                     if not !leading_blank && not trailing_blank then begin

     

       976
       976
       +
                       let breaks = Buffer.contents trailing_breaks in

     

       977
       977
       +
                       if String.length breaks = 1 then

     

       978
       978
       +
                         Buffer.add_char buf ' '

     

       979
       979
       +
                       else

     

       980
       980
       +
                         Buffer.add_substring buf breaks 1 (String.length breaks - 1)

     

       981
       981
       +
                     end else begin

     

       982
       982
       +
                       (* Preserve breaks for more-indented lines *)

     

       983
       983
       +
                       Buffer.add_buffer buf trailing_breaks

     

       984
       984
       +
                     end

     

       985
       985
       +
                   end

     

       986
       986
       +
                 end else if not literal then

     

       987
       987
       +
                   Buffer.add_char buf ' '

     

       988
       988
       +
               end else

     

       989
       989
       +
                 Buffer.add_buffer buf trailing_breaks;

     

       990
       990
       +
               Buffer.clear trailing_breaks;

     

       991
       991
       +
       

     

       992
       992
       +
               (* Add extra indentation for literal or more-indented folded lines *)

     

       993
       993
       +
               (* On the first line (when determining content_indent), we've already consumed all spaces,

     

       994
       994
       +
                  so we should NOT add any back. On subsequent lines, we add only the spaces beyond content_indent. *)

     

       995
       995
       +
               if not first_line && (literal || (!extra_spaces > 0 && not literal)) then begin

     

       996
       996
       +
                 for _ = 1 to !extra_spaces do

     

       997
       997
       +
                   Buffer.add_char buf ' '

     

       998
       998
       +
                 done

     

       999
       999
       +
               end;

     

       1000
       1000
       +
       

     

       1001
       1001
       +
               (* Read line content *)

     

       1002
       1002
       +
               while not (Input.is_eof t.input) && not (Input.next_is_break t.input) do

     

       1003
       1003
       +
                 Buffer.add_char buf (Input.next_exn t.input)

     

       1004
       1004
       +
               done;

     

       1005
       1005
       +
       

     

       1006
       1006
       +
               (* Record trailing break *)

     

       1007
       1007
       +
               if Input.next_is_break t.input then begin

     

       1008
       1008
       +
                 Buffer.add_char trailing_breaks '\n';

     

       1009
       1009
       +
                 Input.consume_break t.input

     

       1010
       1010
       +
               end;

     

       1011
       1011
       +
       

     

       1012
       1012
       +
               (* Update leading_blank for next iteration *)

     

       1013
       1013
       +
               leading_blank := trailing_blank;

     

       1014
       1014
       +
       

     

       1015
       1015
       +
               read_lines ()

     

       1016
       1016
       +
             end

     

       1017
       1017
       +
           end

     

       1018
       1018
       +
         in

     

       1019
       1019
       +
       

     

       1020
       1020
       +
         read_lines ();

     

       1021
       1021
       +
       

     

       1022
       1022
       +
         (* Apply chomping *)

     

       1023
       1023
       +
         let value =

     

       1024
       1024
       +
           let content = Buffer.contents buf in

     

       1025
       1025
       +
           match !chomping with

     

       1026
       1026
       +
           | Chomping.Strip -> content

     

       1027
       1027
       +
           | Chomping.Clip ->

     

       1028
       1028
       +
               if String.length content > 0 then content ^ "\n" else content

     

       1029
       1029
       +
           | Chomping.Keep ->

     

       1030
       1030
       +
               content ^ Buffer.contents trailing_breaks

     

       1031
       1031
       +
         in

     

       1032
       1032
       +
       

     

       1033
       1033
       +
         let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       1034
       1034
       +
         let style = if literal then `Literal else `Folded in

     

       1035
       1035
       +
         (value, style, span)

     

       1036
       1036
       +
       

     

       1037
       1037
       +
       (** Scan directive (after %) *)

     

       1038
       1038
       +
       let scan_directive t =

     

       1039
       1039
       +
         let start = Input.mark t.input in

     

       1040
       1040
       +
         ignore (Input.next t.input); (* consume % *)

     

       1041
       1041
       +
       

     

       1042
       1042
       +
         (* Read directive name *)

     

       1043
       1043
       +
         let name_buf = Buffer.create 16 in

     

       1044
       1044
       +
         while

     

       1045
       1045
       +
           match Input.peek t.input with

     

       1046
       1046
       +
           | Some c when Input.is_alnum c || c = '-' ->

     

       1047
       1047
       +
               Buffer.add_char name_buf c;

     

       1048
       1048
       +
               ignore (Input.next t.input);

     

       1049
       1049
       +
               true

     

       1050
       1050
       +
           | _ -> false

     

       1051
       1051
       +
         do () done;

     

       1052
       1052
       +
         let name = Buffer.contents name_buf in

     

       1053
       1053
       +
       

     

       1054
       1054
       +
         (* Skip blanks *)

     

       1055
       1055
       +
         while Input.next_is_blank t.input do

     

       1056
       1056
       +
           ignore (Input.next t.input)

     

       1057
       1057
       +
         done;

     

       1058
       1058
       +
       

     

       1059
       1059
       +
         match name with

     

       1060
       1060
       +
         | "YAML" ->

     

       1061
       1061
       +
             (* Version directive: %YAML 1.2 *)

     

       1062
       1062
       +
             let major = ref 0 in

     

       1063
       1063
       +
             let minor = ref 0 in

     

       1064
       1064
       +
             (* Read major version *)

     

       1065
       1065
       +
             while Input.next_is_digit t.input do

     

       1066
       1066
       +
               major := !major * 10 + (Char.code (Input.next_exn t.input) - Char.code '0')

     

       1067
       1067
       +
             done;

     

       1068
       1068
       +
             (* Expect . *)

     

       1069
       1069
       +
             (match Input.peek t.input with

     

       1070
       1070
       +
              | Some '.' -> ignore (Input.next t.input)

     

       1071
       1071
       +
              | _ -> Error.raise_at (Input.mark t.input) (Invalid_yaml_version "expected '.'"));

     

       1072
       1072
       +
             (* Read minor version *)

     

       1073
       1073
       +
             while Input.next_is_digit t.input do

     

       1074
       1074
       +
               minor := !minor * 10 + (Char.code (Input.next_exn t.input) - Char.code '0')

     

       1075
       1075
       +
             done;

     

       1076
       1076
       +
             (* Validate: only whitespace and comments allowed before line break (MUS6) *)

     

       1077
       1077
       +
             skip_whitespace_and_comment t;

     

       1078
       1078
       +
             if not (Input.next_is_break t.input) && not (Input.is_eof t.input) then

     

       1079
       1079
       +
               Error.raise_at (Input.mark t.input) (Invalid_directive "expected comment or line break after version");

     

       1080
       1080
       +
             let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       1081
       1081
       +
             Token.Version_directive { major = !major; minor = !minor }, span

     

       1082
       1082
       +
       

     

       1083
       1083
       +
         | "TAG" ->

     

       1084
       1084
       +
             (* Tag directive: %TAG !foo! tag:example.com,2000: *)

     

       1085
       1085
       +
             let handle = scan_tag_handle t in

     

       1086
       1086
       +
             (* Skip blanks *)

     

       1087
       1087
       +
             while Input.next_is_blank t.input do

     

       1088
       1088
       +
               ignore (Input.next t.input)

     

       1089
       1089
       +
             done;

     

       1090
       1090
       +
             (* Read prefix *)

     

       1091
       1091
       +
             let prefix_buf = Buffer.create 32 in

     

       1092
       1092
       +
             while

     

       1093
       1093
       +
               match Input.peek t.input with

     

       1094
       1094
       +
               | Some c when not (Input.is_whitespace c) ->

     

       1095
       1095
       +
                   Buffer.add_char prefix_buf c;

     

       1096
       1096
       +
                   ignore (Input.next t.input);

     

       1097
       1097
       +
                   true

     

       1098
       1098
       +
               | _ -> false

     

       1099
       1099
       +
             do () done;

     

       1100
       1100
       +
             let prefix = Buffer.contents prefix_buf in

     

       1101
       1101
       +
             let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       1102
       1102
       +
             Token.Tag_directive { handle; prefix }, span

     

       1103
       1103
       +
       

     

       1104
       1104
       +
         | _ ->

     

       1105
       1105
       +
             (* Reserved/Unknown directive - skip to end of line and ignore *)

     

       1106
       1106
       +
             (* Per YAML spec, reserved directives should be ignored with a warning *)

     

       1107
       1107
       +
             while not (Input.is_eof t.input) && not (Input.next_is_break t.input) do

     

       1108
       1108
       +
               ignore (Input.next t.input)

     

       1109
       1109
       +
             done;

     

       1110
       1110
       +
             let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       1111
       1111
       +
             (* Return an empty tag directive token to indicate directive was processed but ignored *)

     

       1112
       1112
       +
             Token.Tag_directive { handle = ""; prefix = "" }, span

     

       1113
       1113
       +
       

     

       1114
       1114
       +
       (** Fetch the next token(s) into the queue *)

     

       1115
       1115
       +
       let rec fetch_next_token t =

     

       1116
       1116
       +
         skip_to_next_token t;

     

       1117
       1117
       +
         stale_simple_keys t;

     

       1118
       1118
       +
         let col = column t in

     

       1119
       1119
       +
         (* Unroll indents that are deeper than current column.

     

       1120
       1120
       +
            Note: we use col, not col-1, to allow entries at the same level. *)

     

       1121
       1121
       +
         unroll_indent t col;

     

       1122
       1122
       +
       

     

       1123
       1123
       +
         (* We're about to process actual content, not leading whitespace *)

     

       1124
       1124
       +
         t.leading_whitespace <- false;

     

       1125
       1125
       +
       

     

       1126
       1126
       +
         if Input.is_eof t.input then

     

       1127
       1127
       +
           fetch_stream_end t

     

       1128
       1128
       +
         else if Input.at_document_boundary t.input then

     

       1129
       1129
       +
           fetch_document_indicator t

     

       1130
       1130
       +
         else begin

     

       1131
       1131
       +
           match Input.peek t.input with

     

       1132
       1132
       +
           | None -> fetch_stream_end t

     

       1133
       1133
       +
           | Some '%' when (Input.position t.input).column = 1 ->

     

       1134
       1134
       +
               fetch_directive t

     

       1135
       1135
       +
           | Some '[' -> fetch_flow_collection_start t Token.Flow_sequence_start

     

       1136
       1136
       +
           | Some '{' -> fetch_flow_collection_start t Token.Flow_mapping_start

     

       1137
       1137
       +
           | Some ']' -> fetch_flow_collection_end t Token.Flow_sequence_end

     

       1138
       1138
       +
           | Some '}' -> fetch_flow_collection_end t Token.Flow_mapping_end

     

       1139
       1139
       +
           | Some ',' -> fetch_flow_entry t

     

       1140
       1140
       +
           | Some '-' when t.flow_level = 0 && check_block_entry t ->

     

       1141
       1141
       +
               fetch_block_entry t

     

       1142
       1142
       +
           | Some '?' when check_key t ->

     

       1143
       1143
       +
               fetch_key t

     

       1144
       1144
       +
           | Some ':' when check_value t ->

     

       1145
       1145
       +
               fetch_value t

     

       1146
       1146
       +
           | Some '*' -> fetch_alias t

     

       1147
       1147
       +
           | Some '&' -> fetch_anchor t

     

       1148
       1148
       +
           | Some '!' -> fetch_tag t

     

       1149
       1149
       +
           | Some '|' when t.flow_level = 0 -> fetch_block_scalar t true

     

       1150
       1150
       +
           | Some '>' when t.flow_level = 0 -> fetch_block_scalar t false

     

       1151
       1151
       +
           | Some '\'' -> fetch_single_quoted t

     

       1152
       1152
       +
           | Some '"' -> fetch_double_quoted t

     

       1153
       1153
       +
           | Some '-' when can_start_plain t ->

     

       1154
       1154
       +
               fetch_plain_scalar t

     

       1155
       1155
       +
           | Some '?' when can_start_plain t ->

     

       1156
       1156
       +
               fetch_plain_scalar t

     

       1157
       1157
       +
           | Some ':' when can_start_plain t ->

     

       1158
       1158
       +
               fetch_plain_scalar t

     

       1159
       1159
       +
           | Some c when can_start_plain_char c t ->

     

       1160
       1160
       +
               fetch_plain_scalar t

     

       1161
       1161
       +
           | Some c ->

     

       1162
       1162
       +
               Error.raise_at (Input.mark t.input) (Unexpected_character c)

     

       1163
       1163
       +
         end

     

       1164
       1164
       +
       

     

       1165
       1165
       +
       and fetch_stream_end t =

     

       1166
       1166
       +
         if not t.stream_ended then begin

     

       1167
       1167
       +
           unroll_indent t (-1);

     

       1168
       1168
       +
           remove_simple_key t;

     

       1169
       1169
       +
           t.allow_simple_key <- false;

     

       1170
       1170
       +
           t.stream_ended <- true;

     

       1171
       1171
       +
           let span = Span.point (Input.mark t.input) in

     

       1172
       1172
       +
           emit t span Token.Stream_end

     

       1173
       1173
       +
         end

     

       1174
       1174
       +
       

     

       1175
       1175
       +
       and fetch_document_indicator t =

     

       1176
       1176
       +
         unroll_indent t (-1);

     

       1177
       1177
       +
         remove_simple_key t;

     

       1178
       1178
       +
         t.allow_simple_key <- false;

     

       1179
       1179
       +
         let start = Input.mark t.input in

     

       1180
       1180
       +
         let indicator = Input.peek_string t.input 3 in

     

       1181
       1181
       +
         Input.skip t.input 3;

     

       1182
       1182
       +
         let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       1183
       1183
       +
         let token = if indicator = "---" then Token.Document_start else Token.Document_end in

     

       1184
       1184
       +
         (* Reset document content flag after document end marker *)

     

       1185
       1185
       +
         if indicator = "..." then begin

     

       1186
       1186
       +
           t.document_has_content <- false;

     

       1187
       1187
       +
           (* After document end marker, skip whitespace and check for end of line or comment *)

     

       1188
       1188
       +
           while Input.next_is_blank t.input do ignore (Input.next t.input) done;

     

       1189
       1189
       +
           (match Input.peek t.input with

     

       1190
       1190
       +
            | None -> ()  (* EOF is ok *)

     

       1191
       1191
       +
            | Some c when Input.is_break c -> ()

     

       1192
       1192
       +
            | Some '#' -> ()  (* Comment is ok *)

     

       1193
       1193
       +
            | _ -> Error.raise_at start (Invalid_directive "content not allowed after document end marker on same line"))

     

       1194
       1194
       +
         end;

     

       1195
       1195
       +
         emit t span token

     

       1196
       1196
       +
       

     

       1197
       1197
       +
       and fetch_directive t =

     

       1198
       1198
       +
         (* Directives can only appear:

     

       1199
       1199
       +
            1. At stream start (before any document content)

     

       1200
       1200
       +
            2. After a document end marker (...)

     

       1201
       1201
       +
            If we've emitted content in the current document, we need a document end marker first *)

     

       1202
       1202
       +
         if t.document_has_content then

     

       1203
       1203
       +
           Error.raise_at (Input.mark t.input)

     

       1204
       1204
       +
             (Unexpected_token "directives must be separated from document content by document end marker (...)");

     

       1205
       1205
       +
         unroll_indent t (-1);

     

       1206
       1206
       +
         remove_simple_key t;

     

       1207
       1207
       +
         t.allow_simple_key <- false;

     

       1208
       1208
       +
         let token, span = scan_directive t in

     

       1209
       1209
       +
         emit t span token

     

       1210
       1210
       +
       

     

       1211
       1211
       +
       and fetch_flow_collection_start t token_type =

     

       1212
       1212
       +
         save_simple_key t;

     

       1213
       1213
       +
         (* Record indent of outermost flow collection *)

     

       1214
       1214
       +
         if t.flow_level = 0 then

     

       1215
       1215
       +
           t.flow_indent <- column t;

     

       1216
       1216
       +
         t.flow_level <- t.flow_level + 1;

     

       1217
       1217
       +
         (* Track whether this is a mapping or sequence *)

     

       1218
       1218
       +
         let is_mapping = (token_type = Token.Flow_mapping_start) in

     

       1219
       1219
       +
         t.flow_mapping_stack <- is_mapping :: t.flow_mapping_stack;

     

       1220
       1220
       +
         t.allow_simple_key <- true;

     

       1221
       1221
       +
         t.simple_keys <- None :: t.simple_keys;

     

       1222
       1222
       +
         t.document_has_content <- true;

     

       1223
       1223
       +
         let start = Input.mark t.input in

     

       1224
       1224
       +
         ignore (Input.next t.input);

     

       1225
       1225
       +
         let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       1226
       1226
       +
         emit t span token_type

     

       1227
       1227
       +
       

     

       1228
       1228
       +
       and fetch_flow_collection_end t token_type =

     

       1229
       1229
       +
         remove_simple_key t;

     

       1230
       1230
       +
         t.flow_level <- t.flow_level - 1;

     

       1231
       1231
       +
         t.flow_mapping_stack <- (match t.flow_mapping_stack with _ :: rest -> rest | [] -> []);

     

       1232
       1232
       +
         t.simple_keys <- (match t.simple_keys with _ :: rest -> rest | [] -> []);

     

       1233
       1233
       +
         t.allow_simple_key <- false;

     

       1234
       1234
       +
         let start = Input.mark t.input in

     

       1235
       1235
       +
         ignore (Input.next t.input);

     

       1236
       1236
       +
         (* Allow adjacent values after flow collection ends *)

     

       1237
       1237
       +
         if t.flow_level > 0 then

     

       1238
       1238
       +
           t.adjacent_value_allowed_at <- Some (Input.position t.input);

     

       1239
       1239
       +
         let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       1240
       1240
       +
         emit t span token_type

     

       1241
       1241
       +
       

     

       1242
       1242
       +
       and fetch_flow_entry t =

     

       1243
       1243
       +
         remove_simple_key t;

     

       1244
       1244
       +
         t.allow_simple_key <- true;

     

       1245
       1245
       +
         let start = Input.mark t.input in

     

       1246
       1246
       +
         ignore (Input.next t.input);

     

       1247
       1247
       +
         let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       1248
       1248
       +
         emit t span Token.Flow_entry

     

       1249
       1249
       +
       

     

       1250
       1250
       +
       and check_block_entry t =

     

       1251
       1251
       +
         (* - followed by whitespace or EOF *)

     

       1252
       1252
       +
         match Input.peek_nth t.input 1 with

     

       1253
       1253
       +
         | None -> true

     

       1254
       1254
       +
         | Some c -> Input.is_whitespace c

     

       1255
       1255
       +
       

     

       1256
       1256
       +
       and fetch_block_entry t =

     

       1257
       1257
       +
         if t.flow_level = 0 then begin

     

       1258
       1258
       +
           (* Block entries require allow_simple_key to be true.

     

       1259
       1259
       +
              This prevents block sequences on the same line as a mapping value,

     

       1260
       1260
       +
              e.g., "key: - a" is invalid. *)

     

       1261
       1261
       +
           if not t.allow_simple_key then

     

       1262
       1262
       +
             Error.raise_at (Input.mark t.input) Block_sequence_disallowed;

     

       1263
       1263
       +
           let col = column t in

     

       1264
       1264
       +
           if roll_indent t col ~sequence:true then begin

     

       1265
       1265
       +
             let span = Span.point (Input.mark t.input) in

     

       1266
       1266
       +
             emit t span Token.Block_sequence_start

     

       1267
       1267
       +
           end

     

       1268
       1268
       +
         end;

     

       1269
       1269
       +
         remove_simple_key t;

     

       1270
       1270
       +
         t.allow_simple_key <- true;

     

       1271
       1271
       +
         t.document_has_content <- true;

     

       1272
       1272
       +
         let start = Input.mark t.input in

     

       1273
       1273
       +
         ignore (Input.next t.input);

     

       1274
       1274
       +
       

     

       1275
       1275
       +
         (* Check for tabs after - : pattern like -\t- is invalid *)

     

       1276
       1276
       +
         let (found_tabs, _found_spaces) = skip_blanks_check_tabs t in

     

       1277
       1277
       +
         if found_tabs then begin

     

       1278
       1278
       +
           (* If we found tabs and next char is - followed by whitespace, error *)

     

       1279
       1279
       +
           match Input.peek t.input with

     

       1280
       1280
       +
           | Some '-' ->

     

       1281
       1281
       +
               (match Input.peek_nth t.input 1 with

     

       1282
       1282
       +
                | None -> Error.raise_at start Tab_in_indentation

     

       1283
       1283
       +
                | Some c when Input.is_whitespace c ->

     

       1284
       1284
       +
                    Error.raise_at start Tab_in_indentation

     

       1285
       1285
       +
                | Some _ -> ())

     

       1286
       1286
       +
           | _ -> ()

     

       1287
       1287
       +
         end;

     

       1288
       1288
       +
       

     

       1289
       1289
       +
         let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       1290
       1290
       +
         emit t span Token.Block_entry

     

       1291
       1291
       +
       

     

       1292
       1292
       +
       and check_key t =

     

       1293
       1293
       +
         (* ? followed by whitespace or flow indicator in both block and flow *)

     

       1294
       1294
       +
         match Input.peek_nth t.input 1 with

     

       1295
       1295
       +
           | None -> true

     

       1296
       1296
       +
           | Some c ->

     

       1297
       1297
       +
               Input.is_whitespace c ||

     

       1298
       1298
       +
               (t.flow_level > 0 && Input.is_flow_indicator c)

     

       1299
       1299
       +
       

     

       1300
       1300
       +
       and fetch_key t =

     

       1301
       1301
       +
         if t.flow_level = 0 then begin

     

       1302
       1302
       +
           if not t.allow_simple_key then

     

       1303
       1303
       +
             Error.raise_at (Input.mark t.input) Expected_key;

     

       1304
       1304
       +
           let col = column t in

     

       1305
       1305
       +
           if roll_indent t col ~sequence:false then begin

     

       1306
       1306
       +
             let span = Span.point (Input.mark t.input) in

     

       1307
       1307
       +
             emit t span Token.Block_mapping_start

     

       1308
       1308
       +
           end

     

       1309
       1309
       +
         end;

     

       1310
       1310
       +
         remove_simple_key t;

     

       1311
       1311
       +
         t.allow_simple_key <- t.flow_level = 0;

     

       1312
       1312
       +
         t.document_has_content <- true;

     

       1313
       1313
       +
         let start = Input.mark t.input in

     

       1314
       1314
       +
         ignore (Input.next t.input);

     

       1315
       1315
       +
       

     

       1316
       1316
       +
         (* Check for tabs after ? : pattern like ?\t- or ?\tkey is invalid *)

     

       1317
       1317
       +
         let (found_tabs, _found_spaces) = skip_blanks_check_tabs t in

     

       1318
       1318
       +
         if found_tabs && t.flow_level = 0 then begin

     

       1319
       1319
       +
           (* In block context, tabs after ? are not allowed *)

     

       1320
       1320
       +
           Error.raise_at start Tab_in_indentation

     

       1321
       1321
       +
         end;

     

       1322
       1322
       +
       

     

       1323
       1323
       +
         let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       1324
       1324
       +
         emit t span Token.Key;

     

       1325
       1325
       +
         t.pending_value <- true  (* We've emitted a KEY, now waiting for VALUE *)

     

       1326
       1326
       +
       

     

       1327
       1327
       +
       and check_value t =

     

       1328
       1328
       +
         (* : followed by whitespace in block, or whitespace/flow indicator in flow, or adjacent value *)

     

       1329
       1329
       +
         match Input.peek_nth t.input 1 with

     

       1330
       1330
       +
         | None -> true

     

       1331
       1331
       +
         | Some c ->

     

       1332
       1332
       +
             Input.is_whitespace c ||

     

       1333
       1333
       +
             (t.flow_level > 0 && Input.is_flow_indicator c) ||

     

       1334
       1334
       +
             (* Allow adjacent values in flow context at designated positions *)

     

       1335
       1335
       +
             (t.flow_level > 0 &&

     

       1336
       1336
       +
              match t.adjacent_value_allowed_at with

     

       1337
       1337
       +
              | Some pos -> pos.Position.line = (Input.position t.input).Position.line &&

     

       1338
       1338
       +
                            pos.Position.column = (Input.position t.input).Position.column

     

       1339
       1339
       +
              | None -> false)

     

       1340
       1340
       +
       

     

       1341
       1341
       +
       and fetch_value t =

     

       1342
       1342
       +
         let start = Input.mark t.input in

     

       1343
       1343
       +
         (* Check for simple key *)

     

       1344
       1344
       +
         let used_simple_key =

     

       1345
       1345
       +
           match t.simple_keys with

     

       1346
       1346
       +
           | Some sk :: _ when sk.sk_possible ->

     

       1347
       1347
       +
               (* In implicit flow mapping (inside a flow sequence), key and : must be on the same line.

     

       1348
       1348
       +
                  In explicit flow mapping { }, key and : can span lines. *)

     

       1349
       1349
       +
               let is_implicit_flow_mapping = match t.flow_mapping_stack with

     

       1350
       1350
       +
                 | false :: _ -> true  (* false = we're in a sequence, so any mapping is implicit *)

     

       1351
       1351
       +
                 | _ -> false

     

       1352
       1352
       +
               in

     

       1353
       1353
       +
               if is_implicit_flow_mapping && sk.sk_position.line < (Input.position t.input).line then

     

       1354
       1354
       +
                 Error.raise_at start Illegal_flow_key_line;

     

       1355
       1355
       +
               (* Insert KEY token before the simple key value *)

     

       1356
       1356
       +
               let key_span = Span.point sk.sk_position in

     

       1357
       1357
       +
               let key_token = { Token.token = Token.Key; span = key_span } in

     

       1358
       1358
       +
               (* We need to insert at the right position *)

     

       1359
       1359
       +
               let tokens = Queue.to_seq t.tokens |> Array.of_seq in

     

       1360
       1360
       +
               Queue.clear t.tokens;

     

       1361
       1361
       +
               let insert_pos = sk.sk_token_number - t.tokens_taken in

     

       1362
       1362
       +
               Array.iteri (fun i tok ->

     

       1363
       1363
       +
                 if i = insert_pos then Queue.add key_token t.tokens;

     

       1364
       1364
       +
                 Queue.add tok t.tokens

     

       1365
       1365
       +
               ) tokens;

     

       1366
       1366
       +
               if insert_pos >= Array.length tokens then

     

       1367
       1367
       +
                 Queue.add key_token t.tokens;

     

       1368
       1368
       +
               t.token_number <- t.token_number + 1;

     

       1369
       1369
       +
               t.pending_value <- true;  (* We've inserted a KEY token, now waiting for VALUE *)

     

       1370
       1370
       +
               (* Roll indent for implicit block mapping *)

     

       1371
       1371
       +
               if t.flow_level = 0 then begin

     

       1372
       1372
       +
                 let col = sk.sk_position.column in

     

       1373
       1373
       +
                 if roll_indent t col ~sequence:false then begin

     

       1374
       1374
       +
                   let span = Span.point sk.sk_position in

     

       1375
       1375
       +
                   (* Insert block mapping start before key *)

     

       1376
       1376
       +
                   let bm_token = { Token.token = Token.Block_mapping_start; span } in

     

       1377
       1377
       +
                   let tokens = Queue.to_seq t.tokens |> Array.of_seq in

     

       1378
       1378
       +
                   Queue.clear t.tokens;

     

       1379
       1379
       +
                   Array.iteri (fun i tok ->

     

       1380
       1380
       +
                     if i = insert_pos then Queue.add bm_token t.tokens;

     

       1381
       1381
       +
                     Queue.add tok t.tokens

     

       1382
       1382
       +
                   ) tokens;

     

       1383
       1383
       +
                   if insert_pos >= Array.length tokens then

     

       1384
       1384
       +
                     Queue.add bm_token t.tokens;

     

       1385
       1385
       +
                   t.token_number <- t.token_number + 1

     

       1386
       1386
       +
                 end

     

       1387
       1387
       +
               end;

     

       1388
       1388
       +
               t.simple_keys <- None :: (List.tl t.simple_keys);

     

       1389
       1389
       +
               true

     

       1390
       1390
       +
           | _ ->

     

       1391
       1391
       +
               (* No simple key - this is a complex value (or empty key) *)

     

       1392
       1392
       +
               if t.flow_level = 0 then begin

     

       1393
       1393
       +
                 if not t.allow_simple_key then

     

       1394
       1394
       +
                   Error.raise_at (Input.mark t.input) Expected_key;

     

       1395
       1395
       +
                 let col = column t in

     

       1396
       1396
       +
                 if roll_indent t col ~sequence:false then begin

     

       1397
       1397
       +
                   let span = Span.point (Input.mark t.input) in

     

       1398
       1398
       +
                   emit t span Token.Block_mapping_start

     

       1399
       1399
       +
                 end

     

       1400
       1400
       +
                 (* Note: We don't emit KEY here. Empty key handling is done by the parser,

     

       1401
       1401
       +
                    which emits empty scalar when it sees VALUE without preceding KEY. *)

     

       1402
       1402
       +
               end;

     

       1403
       1403
       +
               false

     

       1404
       1404
       +
         in

     

       1405
       1405
       +
         remove_simple_key t;

     

       1406
       1406
       +
         (* In block context without simple key, allow simple keys for compact mappings like ": moon: white"

     

       1407
       1407
       +
            In flow context or after using a simple key, disallow simple keys *)

     

       1408
       1408
       +
         t.allow_simple_key <- (not used_simple_key) && (t.flow_level = 0);

     

       1409
       1409
       +
         t.document_has_content <- true;

     

       1410
       1410
       +
         let start = Input.mark t.input in

     

       1411
       1411
       +
         ignore (Input.next t.input);

     

       1412
       1412
       +
       

     

       1413
       1413
       +
         (* Check for tabs after : : patterns like :\t- or :\tkey: are invalid in block context (Y79Y/09)

     

       1414
       1414
       +
            However, :\t bar (tab followed by space then content) is valid (6BCT) *)

     

       1415
       1415
       +
         let (found_tabs, found_spaces) = skip_blanks_check_tabs t in

     

       1416
       1416
       +
         if found_tabs && not found_spaces && t.flow_level = 0 then begin

     

       1417
       1417
       +
           (* In block context, tabs-only after : followed by indicator or alphanumeric are not allowed *)

     

       1418
       1418
       +
           match Input.peek t.input with

     

       1419
       1419
       +
           | Some ('-' | '?') ->

     

       1420
       1420
       +
               Error.raise_at start Tab_in_indentation

     

       1421
       1421
       +
           | Some c when (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') ->

     

       1422
       1422
       +
               (* Tab-only followed by alphanumeric - likely a key, which is invalid *)

     

       1423
       1423
       +
               Error.raise_at start Tab_in_indentation

     

       1424
       1424
       +
           | _ -> ()

     

       1425
       1425
       +
         end;

     

       1426
       1426
       +
       

     

       1427
       1427
       +
         (* Skip any comment that may follow the colon and whitespace *)

     

       1428
       1428
       +
         skip_whitespace_and_comment t;

     

       1429
       1429
       +
       

     

       1430
       1430
       +
         let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       1431
       1431
       +
         emit t span Token.Value;

     

       1432
       1432
       +
         t.pending_value <- false  (* We've emitted a VALUE, no longer pending *)

     

       1433
       1433
       +
       

     

       1434
       1434
       +
       and fetch_alias t =

     

       1435
       1435
       +
         save_simple_key t;

     

       1436
       1436
       +
         t.allow_simple_key <- false;

     

       1437
       1437
       +
         t.document_has_content <- true;

     

       1438
       1438
       +
         let start = Input.mark t.input in

     

       1439
       1439
       +
         ignore (Input.next t.input); (* consume * *)

     

       1440
       1440
       +
         let name, span = scan_anchor_alias t in

     

       1441
       1441
       +
         let span = Span.make ~start ~stop:span.stop in

     

       1442
       1442
       +
         emit t span (Token.Alias name)

     

       1443
       1443
       +
       

     

       1444
       1444
       +
       and fetch_anchor t =

     

       1445
       1445
       +
         save_simple_key t;

     

       1446
       1446
       +
         t.allow_simple_key <- false;

     

       1447
       1447
       +
         t.document_has_content <- true;

     

       1448
       1448
       +
         let start = Input.mark t.input in

     

       1449
       1449
       +
         ignore (Input.next t.input); (* consume & *)

     

       1450
       1450
       +
         let name, span = scan_anchor_alias t in

     

       1451
       1451
       +
         let span = Span.make ~start ~stop:span.stop in

     

       1452
       1452
       +
         emit t span (Token.Anchor name)

     

       1453
       1453
       +
       

     

       1454
       1454
       +
       and fetch_tag t =

     

       1455
       1455
       +
         save_simple_key t;

     

       1456
       1456
       +
         t.allow_simple_key <- false;

     

       1457
       1457
       +
         t.document_has_content <- true;

     

       1458
       1458
       +
         let handle, suffix, span = scan_tag t in

     

       1459
       1459
       +
         emit t span (Token.Tag { handle; suffix })

     

       1460
       1460
       +
       

     

       1461
       1461
       +
       and fetch_block_scalar t literal =

     

       1462
       1462
       +
         remove_simple_key t;

     

       1463
       1463
       +
         t.allow_simple_key <- true;

     

       1464
       1464
       +
         t.document_has_content <- true;

     

       1465
       1465
       +
         let value, style, span = scan_block_scalar t literal in

     

       1466
       1466
       +
         emit t span (Token.Scalar { style; value })

     

       1467
       1467
       +
       

     

       1468
       1468
       +
       and fetch_single_quoted t =

     

       1469
       1469
       +
         save_simple_key t;

     

       1470
       1470
       +
         t.allow_simple_key <- false;

     

       1471
       1471
       +
         t.document_has_content <- true;

     

       1472
       1472
       +
         let value, span = scan_single_quoted t in

     

       1473
       1473
       +
         (* Allow adjacent values after quoted scalars in flow context (for JSON compatibility) *)

     

       1474
       1474
       +
         skip_to_next_token t;

     

       1475
       1475
       +
         if t.flow_level > 0 then

     

       1476
       1476
       +
           t.adjacent_value_allowed_at <- Some (Input.position t.input);

     

       1477
       1477
       +
         emit t span (Token.Scalar { style = `Single_quoted; value })

     

       1478
       1478
       +
       

     

       1479
       1479
       +
       and fetch_double_quoted t =

     

       1480
       1480
       +
         save_simple_key t;

     

       1481
       1481
       +
         t.allow_simple_key <- false;

     

       1482
       1482
       +
         t.document_has_content <- true;

     

       1483
       1483
       +
         let value, span = scan_double_quoted t in

     

       1484
       1484
       +
         (* Allow adjacent values after quoted scalars in flow context (for JSON compatibility) *)

     

       1485
       1485
       +
         skip_to_next_token t;

     

       1486
       1486
       +
         if t.flow_level > 0 then

     

       1487
       1487
       +
           t.adjacent_value_allowed_at <- Some (Input.position t.input);

     

       1488
       1488
       +
         emit t span (Token.Scalar { style = `Double_quoted; value })

     

       1489
       1489
       +
       

     

       1490
       1490
       +
       and can_start_plain t =

     

       1491
       1491
       +
         (* Check if - ? : can start a plain scalar *)

     

       1492
       1492
       +
         match Input.peek_nth t.input 1 with

     

       1493
       1493
       +
         | None -> false

     

       1494
       1494
       +
         | Some c ->

     

       1495
       1495
       +
             not (Input.is_whitespace c) &&

     

       1496
       1496
       +
             (t.flow_level = 0 || not (Input.is_flow_indicator c))

     

       1497
       1497
       +
       

     

       1498
       1498
       +
       and can_start_plain_char c _t =

     

       1499
       1499
       +
         (* Characters that can start a plain scalar *)

     

       1500
       1500
       +
         if Input.is_whitespace c then false

     

       1501
       1501
       +
         else if Input.is_indicator c then false

     

       1502
       1502
       +
         else true

     

       1503
       1503
       +
       

     

       1504
       1504
       +
       and fetch_plain_scalar t =

     

       1505
       1505
       +
         save_simple_key t;

     

       1506
       1506
       +
         t.allow_simple_key <- false;

     

       1507
       1507
       +
         t.document_has_content <- true;

     

       1508
       1508
       +
         let value, span, ended_with_linebreak = scan_plain_scalar t in

     

       1509
       1509
       +
         (* If the plain scalar ended after crossing a line break (leading_blanks = true),

     

       1510
       1510
       +
            allow simple keys. This is important because the scanner already consumed the

     

       1511
       1511
       +
            line break and leading whitespace when checking for continuation. *)

     

       1512
       1512
       +
         if ended_with_linebreak then

     

       1513
       1513
       +
           t.allow_simple_key <- true;

     

       1514
       1514
       +
         emit t span (Token.Scalar { style = `Plain; value })

     

       1515
       1515
       +
       

     

       1516
       1516
       +
       (** Check if we need more tokens to resolve simple keys *)

     

       1517
       1517
       +
       let need_more_tokens t =

     

       1518
       1518
       +
         if t.stream_ended then false

     

       1519
       1519
       +
         else if Queue.is_empty t.tokens then true

     

       1520
       1520
       +
         else

     

       1521
       1521
       +
           (* Check if any simple key could affect the first queued token *)

     

       1522
       1522
       +
           List.exists (function

     

       1523
       1523
       +
             | Some sk when sk.sk_possible ->

     

       1524
       1524
       +
                 sk.sk_token_number >= t.tokens_taken

     

       1525
       1525
       +
             | _ -> false

     

       1526
       1526
       +
           ) t.simple_keys

     

       1527
       1527
       +
       

     

       1528
       1528
       +
       (** Ensure we have enough tokens to return one safely *)

     

       1529
       1529
       +
       let ensure_tokens t =

     

       1530
       1530
       +
         if not t.stream_started then begin

     

       1531
       1531
       +
           t.stream_started <- true;

     

       1532
       1532
       +
           let span = Span.point (Input.position t.input) in

     

       1533
       1533
       +
           let encoding, _ = Encoding.detect (Input.source t.input) in

     

       1534
       1534
       +
           emit t span (Token.Stream_start encoding)

     

       1535
       1535
       +
         end;

     

       1536
       1536
       +
         while need_more_tokens t do

     

       1537
       1537
       +
           fetch_next_token t

     

       1538
       1538
       +
         done

     

       1539
       1539
       +
       

     

       1540
       1540
       +
       (** Get next token *)

     

       1541
       1541
       +
       let next t =

     

       1542
       1542
       +
         ensure_tokens t;

     

       1543
       1543
       +
         if Queue.is_empty t.tokens then

     

       1544
       1544
       +
           None

     

       1545
       1545
       +
         else begin

     

       1546
       1546
       +
           t.tokens_taken <- t.tokens_taken + 1;

     

       1547
       1547
       +
           Some (Queue.pop t.tokens)

     

       1548
       1548
       +
         end

     

       1549
       1549
       +
       

     

       1550
       1550
       +
       (** Peek at next token *)

     

       1551
       1551
       +
       let peek t =

     

       1552
       1552
       +
         ensure_tokens t;

     

       1553
       1553
       +
         Queue.peek_opt t.tokens

     

       1554
       1554
       +
       

     

       1555
       1555
       +
       (** Iterate over all tokens *)

     

       1556
       1556
       +
       let iter f t =

     

       1557
       1557
       +
         let rec loop () =

     

       1558
       1558
       +
           match next t with

     

       1559
       1559
       +
           | None -> ()

     

       1560
       1560
       +
           | Some tok -> f tok; loop ()

     

       1561
       1561
       +
         in

     

       1562
       1562
       +
         loop ()

     

       1563
       1563
       +
       

     

       1564
       1564
       +
       (** Fold over all tokens *)

     

       1565
       1565
       +
       let fold f init t =

     

       1566
       1566
       +
         let rec loop acc =

     

       1567
       1567
       +
           match next t with

     

       1568
       1568
       +
           | None -> acc

     

       1569
       1569
       +
           | Some tok -> loop (f acc tok)

     

       1570
       1570
       +
         in

     

       1571
       1571
       +
         loop init

     

       1572
       1572
       +
       

     

       1573
       1573
       +
       (** Convert to list *)

     

       1574
       1574
       +
       let to_list t =

     

       1575
       1575
       +
         fold (fun acc tok -> tok :: acc) [] t |> List.rev

+77

lib/sequence.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
       +
       (** YAML sequence (array) values with metadata *)

     

       7
       7
       +
       

     

       8
       8
       +
       type 'a t = {

     

       9
       9
       +
         anchor : string option;

     

       10
       10
       +
         tag : string option;

     

       11
       11
       +
         implicit : bool;

     

       12
       12
       +
         style : Layout_style.t;

     

       13
       13
       +
         members : 'a list;

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       let make

     

       17
       17
       +
           ?(anchor : string option)

     

       18
       18
       +
           ?(tag : string option)

     

       19
       19
       +
           ?(implicit = true)

     

       20
       20
       +
           ?(style = `Any)

     

       21
       21
       +
           members =

     

       22
       22
       +
         { anchor; tag; implicit; style; members }

     

       23
       23
       +
       

     

       24
       24
       +
       let members t = t.members

     

       25
       25
       +
       let anchor t = t.anchor

     

       26
       26
       +
       let tag t = t.tag

     

       27
       27
       +
       let implicit t = t.implicit

     

       28
       28
       +
       let style t = t.style

     

       29
       29
       +
       

     

       30
       30
       +
       let with_anchor anchor t = { t with anchor = Some anchor }

     

       31
       31
       +
       let with_tag tag t = { t with tag = Some tag }

     

       32
       32
       +
       let with_style style t = { t with style }

     

       33
       33
       +
       

     

       34
       34
       +
       let map f t = { t with members = List.map f t.members }

     

       35
       35
       +
       

     

       36
       36
       +
       let length t = List.length t.members

     

       37
       37
       +
       

     

       38
       38
       +
       let is_empty t = t.members = []

     

       39
       39
       +
       

     

       40
       40
       +
       let nth t n = List.nth t.members n

     

       41
       41
       +
       

     

       42
       42
       +
       let nth_opt t n = List.nth_opt t.members n

     

       43
       43
       +
       

     

       44
       44
       +
       let iter f t = List.iter f t.members

     

       45
       45
       +
       

     

       46
       46
       +
       let fold f init t = List.fold_left f init t.members

     

       47
       47
       +
       

     

       48
       48
       +
       let pp pp_elem fmt t =

     

       49
       49
       +
         Format.fprintf fmt "@[<hv 2>sequence(@,";

     

       50
       50
       +
         (match t.anchor with

     

       51
       51
       +
          | Some a -> Format.fprintf fmt "anchor=%s,@ " a

     

       52
       52
       +
          | None -> ());

     

       53
       53
       +
         (match t.tag with

     

       54
       54
       +
          | Some tag -> Format.fprintf fmt "tag=%s,@ " tag

     

       55
       55
       +
          | None -> ());

     

       56
       56
       +
         Format.fprintf fmt "style=%a,@ " Layout_style.pp t.style;

     

       57
       57
       +
         Format.fprintf fmt "members=[@,%a@]@,)"

     

       58
       58
       +
           (Format.pp_print_list ~pp_sep:(fun fmt () -> Format.fprintf fmt ",@ ") pp_elem)

     

       59
       59
       +
           t.members

     

       60
       60
       +
       

     

       61
       61
       +
       let equal eq a b =

     

       62
       62
       +
         Option.equal String.equal a.anchor b.anchor &&

     

       63
       63
       +
         Option.equal String.equal a.tag b.tag &&

     

       64
       64
       +
         a.implicit = b.implicit &&

     

       65
       65
       +
         Layout_style.equal a.style b.style &&

     

       66
       66
       +
         List.equal eq a.members b.members

     

       67
       67
       +
       

     

       68
       68
       +
       let compare cmp a b =

     

       69
       69
       +
         let c = Option.compare String.compare a.anchor b.anchor in

     

       70
       70
       +
         if c <> 0 then c else

     

       71
       71
       +
         let c = Option.compare String.compare a.tag b.tag in

     

       72
       72
       +
         if c <> 0 then c else

     

       73
       73
       +
         let c = Bool.compare a.implicit b.implicit in

     

       74
       74
       +
         if c <> 0 then c else

     

       75
       75
       +
         let c = Layout_style.compare a.style b.style in

     

       76
       76
       +
         if c <> 0 then c else

     

       77
       77
       +
         List.compare cmp a.members b.members

+369

lib/serialize.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
       +
       (** Serialize - high-level serialization to buffers and event streams

     

       7
       7
       +
       

     

       8
       8
       +
           This module provides functions to convert YAML values to events and strings.

     

       9
       9
       +
           Both {!Emitter.t}-based and function-based emission APIs are provided. *)

     

       10
       10
       +
       

     

       11
       11
       +
       (** {1 Internal Helpers} *)

     

       12
       12
       +
       

     

       13
       13
       +
       (** Emit a YAML node using an emit function.

     

       14
       14
       +
           This is the core implementation used by both Emitter.t and function-based APIs. *)

     

       15
       15
       +
       let rec emit_yaml_node_impl ~emit (yaml : Yaml.t) =

     

       16
       16
       +
         match yaml with

     

       17
       17
       +
         | `Scalar s ->

     

       18
       18
       +
             emit (Event.Scalar {

     

       19
       19
       +
               anchor = Scalar.anchor s;

     

       20
       20
       +
               tag = Scalar.tag s;

     

       21
       21
       +
               value = Scalar.value s;

     

       22
       22
       +
               plain_implicit = Scalar.plain_implicit s;

     

       23
       23
       +
               quoted_implicit = Scalar.quoted_implicit s;

     

       24
       24
       +
               style = Scalar.style s;

     

       25
       25
       +
             })

     

       26
       26
       +
       

     

       27
       27
       +
         | `Alias name ->

     

       28
       28
       +
             emit (Event.Alias { anchor = name })

     

       29
       29
       +
       

     

       30
       30
       +
         | `A seq ->

     

       31
       31
       +
             let members = Sequence.members seq in

     

       32
       32
       +
             let style =

     

       33
       33
       +
               (* Force flow style for empty sequences *)

     

       34
       34
       +
               if members = [] then `Flow

     

       35
       35
       +
               else Sequence.style seq

     

       36
       36
       +
             in

     

       37
       37
       +
             emit (Event.Sequence_start {

     

       38
       38
       +
               anchor = Sequence.anchor seq;

     

       39
       39
       +
               tag = Sequence.tag seq;

     

       40
       40
       +
               implicit = Sequence.implicit seq;

     

       41
       41
       +
               style;

     

       42
       42
       +
             });

     

       43
       43
       +
             List.iter (emit_yaml_node_impl ~emit) members;

     

       44
       44
       +
             emit Event.Sequence_end

     

       45
       45
       +
       

     

       46
       46
       +
         | `O map ->

     

       47
       47
       +
             let members = Mapping.members map in

     

       48
       48
       +
             let style =

     

       49
       49
       +
               (* Force flow style for empty mappings *)

     

       50
       50
       +
               if members = [] then `Flow

     

       51
       51
       +
               else Mapping.style map

     

       52
       52
       +
             in

     

       53
       53
       +
             emit (Event.Mapping_start {

     

       54
       54
       +
               anchor = Mapping.anchor map;

     

       55
       55
       +
               tag = Mapping.tag map;

     

       56
       56
       +
               implicit = Mapping.implicit map;

     

       57
       57
       +
               style;

     

       58
       58
       +
             });

     

       59
       59
       +
             List.iter (fun (k, v) ->

     

       60
       60
       +
               emit_yaml_node_impl ~emit k;

     

       61
       61
       +
               emit_yaml_node_impl ~emit v

     

       62
       62
       +
             ) members;

     

       63
       63
       +
             emit Event.Mapping_end

     

       64
       64
       +
       

     

       65
       65
       +
       (** Emit a Value node using an emit function.

     

       66
       66
       +
           This is the core implementation used by both Emitter.t and function-based APIs. *)

     

       67
       67
       +
       let rec emit_value_node_impl ~emit ~config (value : Value.t) =

     

       68
       68
       +
         match value with

     

       69
       69
       +
         | `Null ->

     

       70
       70
       +
             emit (Event.Scalar {

     

       71
       71
       +
               anchor = None; tag = None;

     

       72
       72
       +
               value = "null";

     

       73
       73
       +
               plain_implicit = true; quoted_implicit = false;

     

       74
       74
       +
               style = `Plain;

     

       75
       75
       +
             })

     

       76
       76
       +
       

     

       77
       77
       +
         | `Bool b ->

     

       78
       78
       +
             emit (Event.Scalar {

     

       79
       79
       +
               anchor = None; tag = None;

     

       80
       80
       +
               value = if b then "true" else "false";

     

       81
       81
       +
               plain_implicit = true; quoted_implicit = false;

     

       82
       82
       +
               style = `Plain;

     

       83
       83
       +
             })

     

       84
       84
       +
       

     

       85
       85
       +
         | `Float f ->

     

       86
       86
       +
             let value =

     

       87
       87
       +
               match Float.classify_float f with

     

       88
       88
       +
               | FP_nan -> ".nan"

     

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

     

       90
       90
       +
               | _ ->

     

       91
       91
       +
                   if Float.is_integer f && Float.abs f < 1e15 then

     

       92
       92
       +
                     Printf.sprintf "%.0f" f

     

       93
       93
       +
                   else

     

       94
       94
       +
                     Printf.sprintf "%g" f

     

       95
       95
       +
             in

     

       96
       96
       +
             emit (Event.Scalar {

     

       97
       97
       +
               anchor = None; tag = None;

     

       98
       98
       +
               value;

     

       99
       99
       +
               plain_implicit = true; quoted_implicit = false;

     

       100
       100
       +
               style = `Plain;

     

       101
       101
       +
             })

     

       102
       102
       +
       

     

       103
       103
       +
         | `String s ->

     

       104
       104
       +
             let style = Quoting.choose_style s in

     

       105
       105
       +
             emit (Event.Scalar {

     

       106
       106
       +
               anchor = None; tag = None;

     

       107
       107
       +
               value = s;

     

       108
       108
       +
               plain_implicit = style = `Plain;

     

       109
       109
       +
               quoted_implicit = style <> `Plain;

     

       110
       110
       +
               style;

     

       111
       111
       +
             })

     

       112
       112
       +
       

     

       113
       113
       +
         | `A items ->

     

       114
       114
       +
             let style =

     

       115
       115
       +
               (* Force flow style for empty sequences *)

     

       116
       116
       +
               if items = [] then `Flow

     

       117
       117
       +
               else if config.Emitter.layout_style = `Flow then `Flow

     

       118
       118
       +
               else `Block

     

       119
       119
       +
             in

     

       120
       120
       +
             emit (Event.Sequence_start {

     

       121
       121
       +
               anchor = None; tag = None;

     

       122
       122
       +
               implicit = true;

     

       123
       123
       +
               style;

     

       124
       124
       +
             });

     

       125
       125
       +
             List.iter (emit_value_node_impl ~emit ~config) items;

     

       126
       126
       +
             emit Event.Sequence_end

     

       127
       127
       +
       

     

       128
       128
       +
         | `O pairs ->

     

       129
       129
       +
             let style =

     

       130
       130
       +
               (* Force flow style for empty mappings *)

     

       131
       131
       +
               if pairs = [] then `Flow

     

       132
       132
       +
               else if config.Emitter.layout_style = `Flow then `Flow

     

       133
       133
       +
               else `Block

     

       134
       134
       +
             in

     

       135
       135
       +
             emit (Event.Mapping_start {

     

       136
       136
       +
               anchor = None; tag = None;

     

       137
       137
       +
               implicit = true;

     

       138
       138
       +
               style;

     

       139
       139
       +
             });

     

       140
       140
       +
             List.iter (fun (k, v) ->

     

       141
       141
       +
               let style = Quoting.choose_style k in

     

       142
       142
       +
               emit (Event.Scalar {

     

       143
       143
       +
                 anchor = None; tag = None;

     

       144
       144
       +
                 value = k;

     

       145
       145
       +
                 plain_implicit = style = `Plain;

     

       146
       146
       +
                 quoted_implicit = style <> `Plain;

     

       147
       147
       +
                 style;

     

       148
       148
       +
               });

     

       149
       149
       +
               emit_value_node_impl ~emit ~config v

     

       150
       150
       +
             ) pairs;

     

       151
       151
       +
             emit Event.Mapping_end

     

       152
       152
       +
       

     

       153
       153
       +
       (** Strip anchors from a YAML tree (used when resolving aliases for output) *)

     

       154
       154
       +
       let rec strip_anchors (yaml : Yaml.t) : Yaml.t =

     

       155
       155
       +
         match yaml with

     

       156
       156
       +
         | `Scalar s ->

     

       157
       157
       +
             if Option.is_none (Scalar.anchor s) then yaml

     

       158
       158
       +
             else

     

       159
       159
       +
               `Scalar (Scalar.make

     

       160
       160
       +
                 ?tag:(Scalar.tag s)

     

       161
       161
       +
                 ~plain_implicit:(Scalar.plain_implicit s)

     

       162
       162
       +
                 ~quoted_implicit:(Scalar.quoted_implicit s)

     

       163
       163
       +
                 ~style:(Scalar.style s)

     

       164
       164
       +
                 (Scalar.value s))

     

       165
       165
       +
         | `Alias _ -> yaml

     

       166
       166
       +
         | `A seq ->

     

       167
       167
       +
             `A (Sequence.make

     

       168
       168
       +
               ?tag:(Sequence.tag seq)

     

       169
       169
       +
               ~implicit:(Sequence.implicit seq)

     

       170
       170
       +
               ~style:(Sequence.style seq)

     

       171
       171
       +
               (List.map strip_anchors (Sequence.members seq)))

     

       172
       172
       +
         | `O map ->

     

       173
       173
       +
             `O (Mapping.make

     

       174
       174
       +
               ?tag:(Mapping.tag map)

     

       175
       175
       +
               ~implicit:(Mapping.implicit map)

     

       176
       176
       +
               ~style:(Mapping.style map)

     

       177
       177
       +
               (List.map (fun (k, v) -> (strip_anchors k, strip_anchors v)) (Mapping.members map)))

     

       178
       178
       +
       

     

       179
       179
       +
       (** Emit a document using an emit function *)

     

       180
       180
       +
       let emit_document_impl ?(resolve_aliases = true) ~emit doc =

     

       181
       181
       +
         emit (Event.Document_start {

     

       182
       182
       +
           version = Document.version doc;

     

       183
       183
       +
           implicit = Document.implicit_start doc;

     

       184
       184
       +
         });

     

       185
       185
       +
         (match Document.root doc with

     

       186
       186
       +
          | Some yaml ->

     

       187
       187
       +
              let yaml = if resolve_aliases then

     

       188
       188
       +
                yaml |> Yaml.resolve_aliases |> strip_anchors

     

       189
       189
       +
              else yaml in

     

       190
       190
       +
              emit_yaml_node_impl ~emit yaml

     

       191
       191
       +
          | None ->

     

       192
       192
       +
              emit (Event.Scalar {

     

       193
       193
       +
                anchor = None; tag = None;

     

       194
       194
       +
                value = "";

     

       195
       195
       +
                plain_implicit = true; quoted_implicit = false;

     

       196
       196
       +
                style = `Plain;

     

       197
       197
       +
              }));

     

       198
       198
       +
         emit (Event.Document_end { implicit = Document.implicit_end doc })

     

       199
       199
       +
       

     

       200
       200
       +
       (** {1 Emitter.t-based API} *)

     

       201
       201
       +
       

     

       202
       202
       +
       (** Emit a YAML node to an emitter *)

     

       203
       203
       +
       let emit_yaml_node t yaml =

     

       204
       204
       +
         emit_yaml_node_impl ~emit:(Emitter.emit t) yaml

     

       205
       205
       +
       

     

       206
       206
       +
       (** Emit a complete YAML document to an emitter *)

     

       207
       207
       +
       let emit_yaml t yaml =

     

       208
       208
       +
         let config = Emitter.config t in

     

       209
       209
       +
         Emitter.emit t (Event.Stream_start { encoding = config.encoding });

     

       210
       210
       +
         Emitter.emit t (Event.Document_start { version = None; implicit = true });

     

       211
       211
       +
         emit_yaml_node t yaml;

     

       212
       212
       +
         Emitter.emit t (Event.Document_end { implicit = true });

     

       213
       213
       +
         Emitter.emit t Event.Stream_end

     

       214
       214
       +
       

     

       215
       215
       +
       (** Emit a Value node to an emitter *)

     

       216
       216
       +
       let emit_value_node t value =

     

       217
       217
       +
         let config = Emitter.config t in

     

       218
       218
       +
         emit_value_node_impl ~emit:(Emitter.emit t) ~config value

     

       219
       219
       +
       

     

       220
       220
       +
       (** Emit a complete Value document to an emitter *)

     

       221
       221
       +
       let emit_value t value =

     

       222
       222
       +
         let config = Emitter.config t in

     

       223
       223
       +
         Emitter.emit t (Event.Stream_start { encoding = config.encoding });

     

       224
       224
       +
         Emitter.emit t (Event.Document_start { version = None; implicit = true });

     

       225
       225
       +
         emit_value_node t value;

     

       226
       226
       +
         Emitter.emit t (Event.Document_end { implicit = true });

     

       227
       227
       +
         Emitter.emit t Event.Stream_end

     

       228
       228
       +
       

     

       229
       229
       +
       (** Emit a document to an emitter *)

     

       230
       230
       +
       let emit_document ?resolve_aliases t doc =

     

       231
       231
       +
         emit_document_impl ?resolve_aliases ~emit:(Emitter.emit t) doc

     

       232
       232
       +
       

     

       233
       233
       +
       (** {1 Buffer-based API} *)

     

       234
       234
       +
       

     

       235
       235
       +
       (** Serialize a Value to a buffer.

     

       236
       236
       +
       

     

       237
       237
       +
           @param config Emitter configuration (default: {!Emitter.default_config})

     

       238
       238
       +
           @param buffer Optional buffer to append to; creates new one if not provided

     

       239
       239
       +
           @return The buffer containing serialized YAML *)

     

       240
       240
       +
       let value_to_buffer ?(config = Emitter.default_config) ?buffer value =

     

       241
       241
       +
         let buf = Option.value buffer ~default:(Buffer.create 1024) in

     

       242
       242
       +
         let t = Emitter.create ~config () in

     

       243
       243
       +
         emit_value t value;

     

       244
       244
       +
         Buffer.add_string buf (Emitter.contents t);

     

       245
       245
       +
         buf

     

       246
       246
       +
       

     

       247
       247
       +
       (** Serialize a Yaml.t to a buffer.

     

       248
       248
       +
       

     

       249
       249
       +
           @param config Emitter configuration (default: {!Emitter.default_config})

     

       250
       250
       +
           @param buffer Optional buffer to append to; creates new one if not provided

     

       251
       251
       +
           @return The buffer containing serialized YAML *)

     

       252
       252
       +
       let yaml_to_buffer ?(config = Emitter.default_config) ?buffer yaml =

     

       253
       253
       +
         let buf = Option.value buffer ~default:(Buffer.create 1024) in

     

       254
       254
       +
         let t = Emitter.create ~config () in

     

       255
       255
       +
         emit_yaml t yaml;

     

       256
       256
       +
         Buffer.add_string buf (Emitter.contents t);

     

       257
       257
       +
         buf

     

       258
       258
       +
       

     

       259
       259
       +
       (** Serialize documents to a buffer.

     

       260
       260
       +
       

     

       261
       261
       +
           @param config Emitter configuration (default: {!Emitter.default_config})

     

       262
       262
       +
           @param resolve_aliases Whether to resolve aliases before emission (default: true)

     

       263
       263
       +
           @param buffer Optional buffer to append to; creates new one if not provided

     

       264
       264
       +
           @return The buffer containing serialized YAML *)

     

       265
       265
       +
       let documents_to_buffer ?(config = Emitter.default_config) ?(resolve_aliases = true) ?buffer documents =

     

       266
       266
       +
         let buf = Option.value buffer ~default:(Buffer.create 1024) in

     

       267
       267
       +
         let t = Emitter.create ~config () in

     

       268
       268
       +
         Emitter.emit t (Event.Stream_start { encoding = config.encoding });

     

       269
       269
       +
         List.iter (emit_document ~resolve_aliases t) documents;

     

       270
       270
       +
         Emitter.emit t Event.Stream_end;

     

       271
       271
       +
         Buffer.add_string buf (Emitter.contents t);

     

       272
       272
       +
         buf

     

       273
       273
       +
       

     

       274
       274
       +
       (** {1 String-based API} *)

     

       275
       275
       +
       

     

       276
       276
       +
       (** Serialize a Value to a string.

     

       277
       277
       +
       

     

       278
       278
       +
           @param config Emitter configuration (default: {!Emitter.default_config}) *)

     

       279
       279
       +
       let value_to_string ?(config = Emitter.default_config) value =

     

       280
       280
       +
         Buffer.contents (value_to_buffer ~config value)

     

       281
       281
       +
       

     

       282
       282
       +
       (** Serialize a Yaml.t to a string.

     

       283
       283
       +
       

     

       284
       284
       +
           @param config Emitter configuration (default: {!Emitter.default_config}) *)

     

       285
       285
       +
       let yaml_to_string ?(config = Emitter.default_config) yaml =

     

       286
       286
       +
         Buffer.contents (yaml_to_buffer ~config yaml)

     

       287
       287
       +
       

     

       288
       288
       +
       (** Serialize documents to a string.

     

       289
       289
       +
       

     

       290
       290
       +
           @param config Emitter configuration (default: {!Emitter.default_config})

     

       291
       291
       +
           @param resolve_aliases Whether to resolve aliases before emission (default: true) *)

     

       292
       292
       +
       let documents_to_string ?(config = Emitter.default_config) ?(resolve_aliases = true) documents =

     

       293
       293
       +
         Buffer.contents (documents_to_buffer ~config ~resolve_aliases documents)

     

       294
       294
       +
       

     

       295
       295
       +
       (** {1 Writer-based API}

     

       296
       296
       +
       

     

       297
       297
       +
           These functions write directly to a bytesrw [Bytes.Writer.t],

     

       298
       298
       +
           enabling true streaming output without intermediate string allocation.

     

       299
       299
       +
           Uses the emitter's native Writer support for efficiency. *)

     

       300
       300
       +
       

     

       301
       301
       +
       (** Serialize a Value directly to a Bytes.Writer.

     

       302
       302
       +
       

     

       303
       303
       +
           @param config Emitter configuration (default: {!Emitter.default_config})

     

       304
       304
       +
           @param eod Whether to write end-of-data after serialization (default: true) *)

     

       305
       305
       +
       let value_to_writer ?(config = Emitter.default_config) ?(eod = true) writer value =

     

       306
       306
       +
         let t = Emitter.of_writer ~config writer in

     

       307
       307
       +
         emit_value t value;

     

       308
       308
       +
         if eod then Emitter.flush t

     

       309
       309
       +
       

     

       310
       310
       +
       (** Serialize a Yaml.t directly to a Bytes.Writer.

     

       311
       311
       +
       

     

       312
       312
       +
           @param config Emitter configuration (default: {!Emitter.default_config})

     

       313
       313
       +
           @param eod Whether to write end-of-data after serialization (default: true) *)

     

       314
       314
       +
       let yaml_to_writer ?(config = Emitter.default_config) ?(eod = true) writer yaml =

     

       315
       315
       +
         let t = Emitter.of_writer ~config writer in

     

       316
       316
       +
         emit_yaml t yaml;

     

       317
       317
       +
         if eod then Emitter.flush t

     

       318
       318
       +
       

     

       319
       319
       +
       (** Serialize documents directly to a Bytes.Writer.

     

       320
       320
       +
       

     

       321
       321
       +
           @param config Emitter configuration (default: {!Emitter.default_config})

     

       322
       322
       +
           @param resolve_aliases Whether to resolve aliases before emission (default: true)

     

       323
       323
       +
           @param eod Whether to write end-of-data after serialization (default: true) *)

     

       324
       324
       +
       let documents_to_writer ?(config = Emitter.default_config) ?(resolve_aliases = true) ?(eod = true) writer documents =

     

       325
       325
       +
         let t = Emitter.of_writer ~config writer in

     

       326
       326
       +
         Emitter.emit t (Event.Stream_start { encoding = config.encoding });

     

       327
       327
       +
         List.iter (emit_document ~resolve_aliases t) documents;

     

       328
       328
       +
         Emitter.emit t Event.Stream_end;

     

       329
       329
       +
         if eod then Emitter.flush t

     

       330
       330
       +
       

     

       331
       331
       +
       (** {1 Function-based API}

     

       332
       332
       +
       

     

       333
       333
       +
           These functions accept an emit function [Event.t -> unit] instead of

     

       334
       334
       +
           an {!Emitter.t}, allowing them to work with any event sink

     

       335
       335
       +
           (e.g., streaming writers, custom processors). *)

     

       336
       336
       +
       

     

       337
       337
       +
       (** Emit a YAML node using an emitter function *)

     

       338
       338
       +
       let emit_yaml_node_fn ~emitter yaml =

     

       339
       339
       +
         emit_yaml_node_impl ~emit:emitter yaml

     

       340
       340
       +
       

     

       341
       341
       +
       (** Emit a complete YAML stream using an emitter function *)

     

       342
       342
       +
       let emit_yaml ~emitter ~config yaml =

     

       343
       343
       +
         emitter (Event.Stream_start { encoding = config.Emitter.encoding });

     

       344
       344
       +
         emitter (Event.Document_start { version = None; implicit = true });

     

       345
       345
       +
         emit_yaml_node_fn ~emitter yaml;

     

       346
       346
       +
         emitter (Event.Document_end { implicit = true });

     

       347
       347
       +
         emitter Event.Stream_end

     

       348
       348
       +
       

     

       349
       349
       +
       (** Emit a Value node using an emitter function *)

     

       350
       350
       +
       let emit_value_node_fn ~emitter ~config value =

     

       351
       351
       +
         emit_value_node_impl ~emit:emitter ~config value

     

       352
       352
       +
       

     

       353
       353
       +
       (** Emit a complete Value stream using an emitter function *)

     

       354
       354
       +
       let emit_value ~emitter ~config value =

     

       355
       355
       +
         emitter (Event.Stream_start { encoding = config.Emitter.encoding });

     

       356
       356
       +
         emitter (Event.Document_start { version = None; implicit = true });

     

       357
       357
       +
         emit_value_node_fn ~emitter ~config value;

     

       358
       358
       +
         emitter (Event.Document_end { implicit = true });

     

       359
       359
       +
         emitter Event.Stream_end

     

       360
       360
       +
       

     

       361
       361
       +
       (** Emit a document using an emitter function *)

     

       362
       362
       +
       let emit_document_fn ?resolve_aliases ~emitter doc =

     

       363
       363
       +
         emit_document_impl ?resolve_aliases ~emit:emitter doc

     

       364
       364
       +
       

     

       365
       365
       +
       (** Emit multiple documents using an emitter function *)

     

       366
       366
       +
       let emit_documents ~emitter ~config ?(resolve_aliases = true) documents =

     

       367
       367
       +
         emitter (Event.Stream_start { encoding = config.Emitter.encoding });

     

       368
       368
       +
         List.iter (emit_document_fn ~resolve_aliases ~emitter) documents;

     

       369
       369
       +
         emitter Event.Stream_end

+40

lib/span.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
       +
       (** Source spans representing ranges in input *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t = {

     

       9
       9
       +
         start : Position.t;

     

       10
       10
       +
         stop : Position.t;

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       let make ~start ~stop = { start; stop }

     

       14
       14
       +
       

     

       15
       15
       +
       let point pos = { start = pos; stop = pos }

     

       16
       16
       +
       

     

       17
       17
       +
       let merge a b =

     

       18
       18
       +
         let start = if Position.compare a.start b.start <= 0 then a.start else b.start in

     

       19
       19
       +
         let stop = if Position.compare a.stop b.stop >= 0 then a.stop else b.stop in

     

       20
       20
       +
         { start; stop }

     

       21
       21
       +
       

     

       22
       22
       +
       let extend span pos =

     

       23
       23
       +
         { span with stop = pos }

     

       24
       24
       +
       

     

       25
       25
       +
       let pp fmt t =

     

       26
       26
       +
         if t.start.line = t.stop.line then

     

       27
       27
       +
           Format.fprintf fmt "line %d, columns %d-%d"

     

       28
       28
       +
             t.start.line t.start.column t.stop.column

     

       29
       29
       +
         else

     

       30
       30
       +
           Format.fprintf fmt "lines %d-%d" t.start.line t.stop.line

     

       31
       31
       +
       

     

       32
       32
       +
       let to_string t =

     

       33
       33
       +
         Format.asprintf "%a" pp t

     

       34
       34
       +
       

     

       35
       35
       +
       let compare a b =

     

       36
       36
       +
         let c = Position.compare a.start b.start in

     

       37
       37
       +
         if c <> 0 then c else Position.compare a.stop b.stop

     

       38
       38
       +
       

     

       39
       39
       +
       let equal a b =

     

       40
       40
       +
         Position.equal a.start b.start && Position.equal a.stop b.stop

+73

lib/tag.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
       +
       (** YAML tags for type information *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t = {

     

       9
       9
       +
         handle : string;  (** e.g., "!" or "!!" or "!foo!" *)

     

       10
       10
       +
         suffix : string;  (** e.g., "str", "int", "custom/type" *)

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       let make ~handle ~suffix = { handle; suffix }

     

       14
       14
       +
       

     

       15
       15
       +
       let of_string s =

     

       16
       16
       +
         let len = String.length s in

     

       17
       17
       +
         match len with

     

       18
       18
       +
         | 0 -> None

     

       19
       19
       +
         | _ when s.[0] <> '!' -> None

     

       20
       20
       +
         | 1 -> Some { handle = "!"; suffix = "" }

     

       21
       21
       +
         | _ ->

     

       22
       22
       +
             match s.[1] with

     

       23
       23
       +
             | '!' -> (* !! handle *)

     

       24
       24
       +
                 Some { handle = "!!"; suffix = String.sub s 2 (len - 2) }

     

       25
       25
       +
             | '<' -> (* Verbatim tag !<...> *)

     

       26
       26
       +
                 if len > 2 && s.[len - 1] = '>' then

     

       27
       27
       +
                   Some { handle = "!"; suffix = String.sub s 2 (len - 3) }

     

       28
       28
       +
                 else

     

       29
       29
       +
                   None

     

       30
       30
       +
             | _ -> (* Primary handle or local tag *)

     

       31
       31
       +
                 Some { handle = "!"; suffix = String.sub s 1 (len - 1) }

     

       32
       32
       +
       

     

       33
       33
       +
       let to_string t =

     

       34
       34
       +
         if t.handle = "!" && t.suffix = "" then "!"

     

       35
       35
       +
         else t.handle ^ t.suffix

     

       36
       36
       +
       

     

       37
       37
       +
       let to_uri t =

     

       38
       38
       +
         match t.handle with

     

       39
       39
       +
         | "!!" -> "tag:yaml.org,2002:" ^ t.suffix

     

       40
       40
       +
         | "!" -> "!" ^ t.suffix

     

       41
       41
       +
         | h -> h ^ t.suffix

     

       42
       42
       +
       

     

       43
       43
       +
       let pp fmt t =

     

       44
       44
       +
         Format.pp_print_string fmt (to_string t)

     

       45
       45
       +
       

     

       46
       46
       +
       let equal a b =

     

       47
       47
       +
         String.equal a.handle b.handle && String.equal a.suffix b.suffix

     

       48
       48
       +
       

     

       49
       49
       +
       let compare a b =

     

       50
       50
       +
         let c = String.compare a.handle b.handle in

     

       51
       51
       +
         if c <> 0 then c else String.compare a.suffix b.suffix

     

       52
       52
       +
       

     

       53
       53
       +
       (** Standard tags *)

     

       54
       54
       +
       

     

       55
       55
       +
       let null = { handle = "!!"; suffix = "null" }

     

       56
       56
       +
       let bool = { handle = "!!"; suffix = "bool" }

     

       57
       57
       +
       let int = { handle = "!!"; suffix = "int" }

     

       58
       58
       +
       let float = { handle = "!!"; suffix = "float" }

     

       59
       59
       +
       let str = { handle = "!!"; suffix = "str" }

     

       60
       60
       +
       let seq = { handle = "!!"; suffix = "seq" }

     

       61
       61
       +
       let map = { handle = "!!"; suffix = "map" }

     

       62
       62
       +
       let binary = { handle = "!!"; suffix = "binary" }

     

       63
       63
       +
       let timestamp = { handle = "!!"; suffix = "timestamp" }

     

       64
       64
       +
       

     

       65
       65
       +
       (** Check if tag matches a standard type *)

     

       66
       66
       +
       

     

       67
       67
       +
       let is_null t = equal t null || (t.handle = "!" && t.suffix = "")

     

       68
       68
       +
       let is_bool t = equal t bool

     

       69
       69
       +
       let is_int t = equal t int

     

       70
       70
       +
       let is_float t = equal t float

     

       71
       71
       +
       let is_str t = equal t str

     

       72
       72
       +
       let is_seq t = equal t seq

     

       73
       73
       +
       let is_map t = equal t map

+83

lib/token.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
       +
       (** YAML token types produced by the scanner *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t =

     

       9
       9
       +
         | Stream_start of Encoding.t

     

       10
       10
       +
         | Stream_end

     

       11
       11
       +
         | Version_directive of { major : int; minor : int }

     

       12
       12
       +
         | Tag_directive of { handle : string; prefix : string }

     

       13
       13
       +
         | Document_start    (** --- *)

     

       14
       14
       +
         | Document_end      (** ... *)

     

       15
       15
       +
         | Block_sequence_start

     

       16
       16
       +
         | Block_mapping_start

     

       17
       17
       +
         | Block_entry       (** [-] *)

     

       18
       18
       +
         | Block_end         (** implicit, from dedent *)

     

       19
       19
       +
         | Flow_sequence_start  (** \[ *)

     

       20
       20
       +
         | Flow_sequence_end    (** \] *)

     

       21
       21
       +
         | Flow_mapping_start   (** \{ *)

     

       22
       22
       +
         | Flow_mapping_end     (** \} *)

     

       23
       23
       +
         | Flow_entry        (** [,] *)

     

       24
       24
       +
         | Key               (** ? or implicit key *)

     

       25
       25
       +
         | Value             (** : *)

     

       26
       26
       +
         | Anchor of string  (** &name *)

     

       27
       27
       +
         | Alias of string   (** *name *)

     

       28
       28
       +
         | Tag of { handle : string; suffix : string }

     

       29
       29
       +
         | Scalar of { style : Scalar_style.t; value : string }

     

       30
       30
       +
       

     

       31
       31
       +
       type spanned = {

     

       32
       32
       +
         token : t;

     

       33
       33
       +
         span : Span.t;

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       36
       36
       +
       let pp_token fmt = function

     

       37
       37
       +
         | Stream_start enc ->

     

       38
       38
       +
             Format.fprintf fmt "STREAM-START(%a)" Encoding.pp enc

     

       39
       39
       +
         | Stream_end ->

     

       40
       40
       +
             Format.fprintf fmt "STREAM-END"

     

       41
       41
       +
         | Version_directive { major; minor } ->

     

       42
       42
       +
             Format.fprintf fmt "VERSION-DIRECTIVE(%d.%d)" major minor

     

       43
       43
       +
         | Tag_directive { handle; prefix } ->

     

       44
       44
       +
             Format.fprintf fmt "TAG-DIRECTIVE(%s, %s)" handle prefix

     

       45
       45
       +
         | Document_start ->

     

       46
       46
       +
             Format.fprintf fmt "DOCUMENT-START"

     

       47
       47
       +
         | Document_end ->

     

       48
       48
       +
             Format.fprintf fmt "DOCUMENT-END"

     

       49
       49
       +
         | Block_sequence_start ->

     

       50
       50
       +
             Format.fprintf fmt "BLOCK-SEQUENCE-START"

     

       51
       51
       +
         | Block_mapping_start ->

     

       52
       52
       +
             Format.fprintf fmt "BLOCK-MAPPING-START"

     

       53
       53
       +
         | Block_entry ->

     

       54
       54
       +
             Format.fprintf fmt "BLOCK-ENTRY"

     

       55
       55
       +
         | Block_end ->

     

       56
       56
       +
             Format.fprintf fmt "BLOCK-END"

     

       57
       57
       +
         | Flow_sequence_start ->

     

       58
       58
       +
             Format.fprintf fmt "FLOW-SEQUENCE-START"

     

       59
       59
       +
         | Flow_sequence_end ->

     

       60
       60
       +
             Format.fprintf fmt "FLOW-SEQUENCE-END"

     

       61
       61
       +
         | Flow_mapping_start ->

     

       62
       62
       +
             Format.fprintf fmt "FLOW-MAPPING-START"

     

       63
       63
       +
         | Flow_mapping_end ->

     

       64
       64
       +
             Format.fprintf fmt "FLOW-MAPPING-END"

     

       65
       65
       +
         | Flow_entry ->

     

       66
       66
       +
             Format.fprintf fmt "FLOW-ENTRY"

     

       67
       67
       +
         | Key ->

     

       68
       68
       +
             Format.fprintf fmt "KEY"

     

       69
       69
       +
         | Value ->

     

       70
       70
       +
             Format.fprintf fmt "VALUE"

     

       71
       71
       +
         | Anchor name ->

     

       72
       72
       +
             Format.fprintf fmt "ANCHOR(%s)" name

     

       73
       73
       +
         | Alias name ->

     

       74
       74
       +
             Format.fprintf fmt "ALIAS(%s)" name

     

       75
       75
       +
         | Tag { handle; suffix } ->

     

       76
       76
       +
             Format.fprintf fmt "TAG(%s, %s)" handle suffix

     

       77
       77
       +
         | Scalar { style; value } ->

     

       78
       78
       +
             Format.fprintf fmt "SCALAR(%a, %S)" Scalar_style.pp style value

     

       79
       79
       +
       

     

       80
       80
       +
       let pp fmt t = pp_token fmt t

     

       81
       81
       +
       

     

       82
       82
       +
       let pp_spanned fmt { token; span } =

     

       83
       83
       +
         Format.fprintf fmt "%a at %a" pp_token token Span.pp span

lib/unix/dune

···

       1
       1
       +
       (library

     

       2
       2
       +
        (name yamlrw_unix)

     

       3
       3
       +
        (public_name yamlrw-unix)

     

       4
       4
       +
        (libraries yamlrw bytesrw))

+124

lib/unix/yamlrw_unix.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
       +
       (** Yamlrw Unix - Channel and file I/O for YAML

     

       7
       7
       +
       

     

       8
       8
       +
           This module provides channel and file operations for parsing

     

       9
       9
       +
           and emitting YAML using bytesrw for efficient streaming I/O. *)

     

       10
       10
       +
       

     

       11
       11
       +
       open Bytesrw

     

       12
       12
       +
       open Yamlrw

     

       13
       13
       +
       

     

       14
       14
       +
       (** {1 Types} *)

     

       15
       15
       +
       

     

       16
       16
       +
       type value = Value.t

     

       17
       17
       +
       type yaml = Yaml.t

     

       18
       18
       +
       type document = Document.t

     

       19
       19
       +
       

     

       20
       20
       +
       (** {1 Channel Input} *)

     

       21
       21
       +
       

     

       22
       22
       +
       let value_of_channel

     

       23
       23
       +
           ?(resolve_aliases = true)

     

       24
       24
       +
           ?(max_nodes = Yaml.default_max_alias_nodes)

     

       25
       25
       +
           ?(max_depth = Yaml.default_max_alias_depth)

     

       26
       26
       +
           ic =

     

       27
       27
       +
         let reader = Bytes.Reader.of_in_channel ic in

     

       28
       28
       +
         Loader.value_of_reader ~resolve_aliases ~max_nodes ~max_depth reader

     

       29
       29
       +
       

     

       30
       30
       +
       let yaml_of_channel

     

       31
       31
       +
           ?(resolve_aliases = false)

     

       32
       32
       +
           ?(max_nodes = Yaml.default_max_alias_nodes)

     

       33
       33
       +
           ?(max_depth = Yaml.default_max_alias_depth)

     

       34
       34
       +
           ic =

     

       35
       35
       +
         let reader = Bytes.Reader.of_in_channel ic in

     

       36
       36
       +
         Loader.yaml_of_reader ~resolve_aliases ~max_nodes ~max_depth reader

     

       37
       37
       +
       

     

       38
       38
       +
       let documents_of_channel ic =

     

       39
       39
       +
         let reader = Bytes.Reader.of_in_channel ic in

     

       40
       40
       +
         Loader.documents_of_reader reader

     

       41
       41
       +
       

     

       42
       42
       +
       (** {1 Channel Output} *)

     

       43
       43
       +
       

     

       44
       44
       +
       let value_to_channel

     

       45
       45
       +
           ?(encoding = `Utf8)

     

       46
       46
       +
           ?(scalar_style = `Any)

     

       47
       47
       +
           ?(layout_style = `Any)

     

       48
       48
       +
           oc

     

       49
       49
       +
           (v : value) =

     

       50
       50
       +
         let config = { Emitter.default_config with encoding; scalar_style; layout_style } in

     

       51
       51
       +
         let writer = Bytes.Writer.of_out_channel oc in

     

       52
       52
       +
         Serialize.value_to_writer ~config writer v

     

       53
       53
       +
       

     

       54
       54
       +
       let yaml_to_channel

     

       55
       55
       +
           ?(encoding = `Utf8)

     

       56
       56
       +
           ?(scalar_style = `Any)

     

       57
       57
       +
           ?(layout_style = `Any)

     

       58
       58
       +
           oc

     

       59
       59
       +
           (v : yaml) =

     

       60
       60
       +
         let config = { Emitter.default_config with encoding; scalar_style; layout_style } in

     

       61
       61
       +
         let writer = Bytes.Writer.of_out_channel oc in

     

       62
       62
       +
         Serialize.yaml_to_writer ~config writer v

     

       63
       63
       +
       

     

       64
       64
       +
       let documents_to_channel

     

       65
       65
       +
           ?(encoding = `Utf8)

     

       66
       66
       +
           ?(scalar_style = `Any)

     

       67
       67
       +
           ?(layout_style = `Any)

     

       68
       68
       +
           ?(resolve_aliases = true)

     

       69
       69
       +
           oc

     

       70
       70
       +
           docs =

     

       71
       71
       +
         let config = { Emitter.default_config with encoding; scalar_style; layout_style } in

     

       72
       72
       +
         let writer = Bytes.Writer.of_out_channel oc in

     

       73
       73
       +
         Serialize.documents_to_writer ~config ~resolve_aliases writer docs

     

       74
       74
       +
       

     

       75
       75
       +
       (** {1 File Input} *)

     

       76
       76
       +
       

     

       77
       77
       +
       let value_of_file

     

       78
       78
       +
           ?(resolve_aliases = true)

     

       79
       79
       +
           ?(max_nodes = Yaml.default_max_alias_nodes)

     

       80
       80
       +
           ?(max_depth = Yaml.default_max_alias_depth)

     

       81
       81
       +
           path =

     

       82
       82
       +
         In_channel.with_open_bin path (fun ic ->

     

       83
       83
       +
           value_of_channel ~resolve_aliases ~max_nodes ~max_depth ic)

     

       84
       84
       +
       

     

       85
       85
       +
       let yaml_of_file

     

       86
       86
       +
           ?(resolve_aliases = false)

     

       87
       87
       +
           ?(max_nodes = Yaml.default_max_alias_nodes)

     

       88
       88
       +
           ?(max_depth = Yaml.default_max_alias_depth)

     

       89
       89
       +
           path =

     

       90
       90
       +
         In_channel.with_open_bin path (fun ic ->

     

       91
       91
       +
           yaml_of_channel ~resolve_aliases ~max_nodes ~max_depth ic)

     

       92
       92
       +
       

     

       93
       93
       +
       let documents_of_file path =

     

       94
       94
       +
         In_channel.with_open_bin path documents_of_channel

     

       95
       95
       +
       

     

       96
       96
       +
       (** {1 File Output} *)

     

       97
       97
       +
       

     

       98
       98
       +
       let value_to_file

     

       99
       99
       +
           ?(encoding = `Utf8)

     

       100
       100
       +
           ?(scalar_style = `Any)

     

       101
       101
       +
           ?(layout_style = `Any)

     

       102
       102
       +
           path

     

       103
       103
       +
           v =

     

       104
       104
       +
         Out_channel.with_open_bin path (fun oc ->

     

       105
       105
       +
           value_to_channel ~encoding ~scalar_style ~layout_style oc v)

     

       106
       106
       +
       

     

       107
       107
       +
       let yaml_to_file

     

       108
       108
       +
           ?(encoding = `Utf8)

     

       109
       109
       +
           ?(scalar_style = `Any)

     

       110
       110
       +
           ?(layout_style = `Any)

     

       111
       111
       +
           path

     

       112
       112
       +
           v =

     

       113
       113
       +
         Out_channel.with_open_bin path (fun oc ->

     

       114
       114
       +
           yaml_to_channel ~encoding ~scalar_style ~layout_style oc v)

     

       115
       115
       +
       

     

       116
       116
       +
       let documents_to_file

     

       117
       117
       +
           ?(encoding = `Utf8)

     

       118
       118
       +
           ?(scalar_style = `Any)

     

       119
       119
       +
           ?(layout_style = `Any)

     

       120
       120
       +
           ?(resolve_aliases = true)

     

       121
       121
       +
           path

     

       122
       122
       +
           docs =

     

       123
       123
       +
         Out_channel.with_open_bin path (fun oc ->

     

       124
       124
       +
           documents_to_channel ~encoding ~scalar_style ~layout_style ~resolve_aliases oc docs)

+125

lib/unix/yamlrw_unix.mli

···

       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
       +
       (** Yamlrw Unix - Channel and file I/O for YAML

     

       7
       7
       +
       

     

       8
       8
       +
           This module provides channel and file operations for parsing

     

       9
       9
       +
           and emitting YAML using bytesrw for efficient streaming I/O. *)

     

       10
       10
       +
       

     

       11
       11
       +
       (** {1 Types} *)

     

       12
       12
       +
       

     

       13
       13
       +
       type value = Yamlrw.Value.t

     

       14
       14
       +
       type yaml = Yamlrw.Yaml.t

     

       15
       15
       +
       type document = Yamlrw.Document.t

     

       16
       16
       +
       

     

       17
       17
       +
       (** {1 Channel Input} *)

     

       18
       18
       +
       

     

       19
       19
       +
       val value_of_channel :

     

       20
       20
       +
         ?resolve_aliases:bool ->

     

       21
       21
       +
         ?max_nodes:int ->

     

       22
       22
       +
         ?max_depth:int ->

     

       23
       23
       +
         in_channel ->

     

       24
       24
       +
         value

     

       25
       25
       +
       (** Parse a JSON-compatible value from an input channel.

     

       26
       26
       +
       

     

       27
       27
       +
           @param resolve_aliases Whether to expand aliases (default: true)

     

       28
       28
       +
           @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       29
       29
       +
           @param max_depth Maximum alias nesting depth (default: 100) *)

     

       30
       30
       +
       

     

       31
       31
       +
       val yaml_of_channel :

     

       32
       32
       +
         ?resolve_aliases:bool ->

     

       33
       33
       +
         ?max_nodes:int ->

     

       34
       34
       +
         ?max_depth:int ->

     

       35
       35
       +
         in_channel ->

     

       36
       36
       +
         yaml

     

       37
       37
       +
       (** Parse a full YAML value from an input channel.

     

       38
       38
       +
       

     

       39
       39
       +
           @param resolve_aliases Whether to expand aliases (default: false)

     

       40
       40
       +
           @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       41
       41
       +
           @param max_depth Maximum alias nesting depth (default: 100) *)

     

       42
       42
       +
       

     

       43
       43
       +
       val documents_of_channel : in_channel -> document list

     

       44
       44
       +
       (** Parse multiple YAML documents from an input channel. *)

     

       45
       45
       +
       

     

       46
       46
       +
       (** {1 Channel Output} *)

     

       47
       47
       +
       

     

       48
       48
       +
       val value_to_channel :

     

       49
       49
       +
         ?encoding:Yamlrw.Encoding.t ->

     

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

     

       51
       51
       +
         ?layout_style:Yamlrw.Layout_style.t ->

     

       52
       52
       +
         out_channel ->

     

       53
       53
       +
         value ->

     

       54
       54
       +
         unit

     

       55
       55
       +
       (** Write a JSON-compatible value to an output channel. *)

     

       56
       56
       +
       

     

       57
       57
       +
       val yaml_to_channel :

     

       58
       58
       +
         ?encoding:Yamlrw.Encoding.t ->

     

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

     

       60
       60
       +
         ?layout_style:Yamlrw.Layout_style.t ->

     

       61
       61
       +
         out_channel ->

     

       62
       62
       +
         yaml ->

     

       63
       63
       +
         unit

     

       64
       64
       +
       (** Write a full YAML value to an output channel. *)

     

       65
       65
       +
       

     

       66
       66
       +
       val documents_to_channel :

     

       67
       67
       +
         ?encoding:Yamlrw.Encoding.t ->

     

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

     

       69
       69
       +
         ?layout_style:Yamlrw.Layout_style.t ->

     

       70
       70
       +
         ?resolve_aliases:bool ->

     

       71
       71
       +
         out_channel ->

     

       72
       72
       +
         document list ->

     

       73
       73
       +
         unit

     

       74
       74
       +
       (** Write multiple YAML documents to an output channel. *)

     

       75
       75
       +
       

     

       76
       76
       +
       (** {1 File Input} *)

     

       77
       77
       +
       

     

       78
       78
       +
       val value_of_file :

     

       79
       79
       +
         ?resolve_aliases:bool ->

     

       80
       80
       +
         ?max_nodes:int ->

     

       81
       81
       +
         ?max_depth:int ->

     

       82
       82
       +
         string ->

     

       83
       83
       +
         value

     

       84
       84
       +
       (** Parse a JSON-compatible value from a file. *)

     

       85
       85
       +
       

     

       86
       86
       +
       val yaml_of_file :

     

       87
       87
       +
         ?resolve_aliases:bool ->

     

       88
       88
       +
         ?max_nodes:int ->

     

       89
       89
       +
         ?max_depth:int ->

     

       90
       90
       +
         string ->

     

       91
       91
       +
         yaml

     

       92
       92
       +
       (** Parse a full YAML value from a file. *)

     

       93
       93
       +
       

     

       94
       94
       +
       val documents_of_file : string -> document list

     

       95
       95
       +
       (** Parse multiple YAML documents from a file. *)

     

       96
       96
       +
       

     

       97
       97
       +
       (** {1 File Output} *)

     

       98
       98
       +
       

     

       99
       99
       +
       val value_to_file :

     

       100
       100
       +
         ?encoding:Yamlrw.Encoding.t ->

     

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

     

       102
       102
       +
         ?layout_style:Yamlrw.Layout_style.t ->

     

       103
       103
       +
         string ->

     

       104
       104
       +
         value ->

     

       105
       105
       +
         unit

     

       106
       106
       +
       (** Write a JSON-compatible value to a file. *)

     

       107
       107
       +
       

     

       108
       108
       +
       val yaml_to_file :

     

       109
       109
       +
         ?encoding:Yamlrw.Encoding.t ->

     

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

     

       111
       111
       +
         ?layout_style:Yamlrw.Layout_style.t ->

     

       112
       112
       +
         string ->

     

       113
       113
       +
         yaml ->

     

       114
       114
       +
         unit

     

       115
       115
       +
       (** Write a full YAML value to a file. *)

     

       116
       116
       +
       

     

       117
       117
       +
       val documents_to_file :

     

       118
       118
       +
         ?encoding:Yamlrw.Encoding.t ->

     

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

     

       120
       120
       +
         ?layout_style:Yamlrw.Layout_style.t ->

     

       121
       121
       +
         ?resolve_aliases:bool ->

     

       122
       122
       +
         string ->

     

       123
       123
       +
         document list ->

     

       124
       124
       +
         unit

     

       125
       125
       +
       (** Write multiple YAML documents to a file. *)

+167

lib/value.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
       +
       (** JSON-compatible YAML value representation *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t = [

     

       9
       9
       +
         | `Null

     

       10
       10
       +
         | `Bool of bool

     

       11
       11
       +
         | `Float of float

     

       12
       12
       +
         | `String of string

     

       13
       13
       +
         | `A of t list

     

       14
       14
       +
         | `O of (string * t) list

     

       15
       15
       +
       ]

     

       16
       16
       +
       

     

       17
       17
       +
       (* Type equality is ensured by structural compatibility with Yamlrw.value *)

     

       18
       18
       +
       

     

       19
       19
       +
       (** Constructors *)

     

       20
       20
       +
       

     

       21
       21
       +
       let null : t = `Null

     

       22
       22
       +
       let bool b : t = `Bool b

     

       23
       23
       +
       let int n : t = `Float (Float.of_int n)

     

       24
       24
       +
       let float f : t = `Float f

     

       25
       25
       +
       let string s : t = `String s

     

       26
       26
       +
       

     

       27
       27
       +
       let list f xs : t = `A (List.map f xs)

     

       28
       28
       +
       let obj pairs : t = `O pairs

     

       29
       29
       +
       

     

       30
       30
       +
       (** Type name for error messages *)

     

       31
       31
       +
       let type_name : t -> string = function

     

       32
       32
       +
         | `Null -> "null"

     

       33
       33
       +
         | `Bool _ -> "bool"

     

       34
       34
       +
         | `Float _ -> "float"

     

       35
       35
       +
         | `String _ -> "string"

     

       36
       36
       +
         | `A _ -> "array"

     

       37
       37
       +
         | `O _ -> "object"

     

       38
       38
       +
       

     

       39
       39
       +
       (** Safe accessors (return option) *)

     

       40
       40
       +
       

     

       41
       41
       +
       let as_null = function `Null -> Some () | _ -> None

     

       42
       42
       +
       let as_bool = function `Bool b -> Some b | _ -> None

     

       43
       43
       +
       let as_float = function `Float f -> Some f | _ -> None

     

       44
       44
       +
       let as_string = function `String s -> Some s | _ -> None

     

       45
       45
       +
       let as_list = function `A l -> Some l | _ -> None

     

       46
       46
       +
       let as_assoc = function `O o -> Some o | _ -> None

     

       47
       47
       +
       

     

       48
       48
       +
       let as_int = function

     

       49
       49
       +
         | `Float f ->

     

       50
       50
       +
             let i = Float.to_int f in

     

       51
       51
       +
             if Float.equal (Float.of_int i) f then Some i else None

     

       52
       52
       +
         | _ -> None

     

       53
       53
       +
       

     

       54
       54
       +
       (** Unsafe accessors (raise on type mismatch) *)

     

       55
       55
       +
       

     

       56
       56
       +
       let unwrap_or_type_error expected_type extractor v =

     

       57
       57
       +
         match extractor v with

     

       58
       58
       +
         | Some x -> x

     

       59
       59
       +
         | None -> Error.raise (Type_mismatch (expected_type, type_name v))

     

       60
       60
       +
       

     

       61
       61
       +
       let to_null v = unwrap_or_type_error "null" as_null v

     

       62
       62
       +
       let to_bool v = unwrap_or_type_error "bool" as_bool v

     

       63
       63
       +
       let to_float v = unwrap_or_type_error "float" as_float v

     

       64
       64
       +
       let to_string v = unwrap_or_type_error "string" as_string v

     

       65
       65
       +
       let to_list v = unwrap_or_type_error "array" as_list v

     

       66
       66
       +
       let to_assoc v = unwrap_or_type_error "object" as_assoc v

     

       67
       67
       +
       let to_int v = unwrap_or_type_error "int" as_int v

     

       68
       68
       +
       

     

       69
       69
       +
       (** Object access *)

     

       70
       70
       +
       

     

       71
       71
       +
       let mem key = function

     

       72
       72
       +
         | `O pairs -> List.exists (fun (k, _) -> k = key) pairs

     

       73
       73
       +
         | _ -> false

     

       74
       74
       +
       

     

       75
       75
       +
       let find key = function

     

       76
       76
       +
         | `O pairs -> List.assoc_opt key pairs

     

       77
       77
       +
         | _ -> None

     

       78
       78
       +
       

     

       79
       79
       +
       let get key v =

     

       80
       80
       +
         match find key v with

     

       81
       81
       +
         | Some v -> v

     

       82
       82
       +
         | None -> Error.raise (Key_not_found key)

     

       83
       83
       +
       

     

       84
       84
       +
       let keys = function

     

       85
       85
       +
         | `O pairs -> List.map fst pairs

     

       86
       86
       +
         | v -> Error.raise (Type_mismatch ("object", type_name v))

     

       87
       87
       +
       

     

       88
       88
       +
       let values = function

     

       89
       89
       +
         | `O pairs -> List.map snd pairs

     

       90
       90
       +
         | v -> Error.raise (Type_mismatch ("object", type_name v))

     

       91
       91
       +
       

     

       92
       92
       +
       (** Combinators *)

     

       93
       93
       +
       

     

       94
       94
       +
       let combine v1 v2 =

     

       95
       95
       +
         match v1, v2 with

     

       96
       96
       +
         | `O o1, `O o2 -> `O (o1 @ o2)

     

       97
       97
       +
         | v1, _ -> Error.raise (Type_mismatch ("object", type_name v1))

     

       98
       98
       +
       

     

       99
       99
       +
       let map f = function

     

       100
       100
       +
         | `A l -> `A (List.map f l)

     

       101
       101
       +
         | v -> Error.raise (Type_mismatch ("array", type_name v))

     

       102
       102
       +
       

     

       103
       103
       +
       let filter pred = function

     

       104
       104
       +
         | `A l -> `A (List.filter pred l)

     

       105
       105
       +
         | v -> Error.raise (Type_mismatch ("array", type_name v))

     

       106
       106
       +
       

     

       107
       107
       +
       (** Pretty printing *)

     

       108
       108
       +
       

     

       109
       109
       +
       let rec pp fmt (v : t) =

     

       110
       110
       +
         match v with

     

       111
       111
       +
         | `Null -> Format.pp_print_string fmt "null"

     

       112
       112
       +
         | `Bool b -> Format.pp_print_bool fmt b

     

       113
       113
       +
         | `Float f ->

     

       114
       114
       +
             if Float.is_integer f && Float.abs f < 1e15 then

     

       115
       115
       +
               Format.fprintf fmt "%.0f" f

     

       116
       116
       +
             else

     

       117
       117
       +
               Format.fprintf fmt "%g" f

     

       118
       118
       +
         | `String s -> Format.fprintf fmt "%S" s

     

       119
       119
       +
         | `A [] -> Format.pp_print_string fmt "[]"

     

       120
       120
       +
         | `A items ->

     

       121
       121
       +
             Format.fprintf fmt "@[<hv 2>[@,%a@]@,]"

     

       122
       122
       +
               (Format.pp_print_list ~pp_sep:(fun fmt () -> Format.fprintf fmt ",@ ") pp)

     

       123
       123
       +
               items

     

       124
       124
       +
         | `O [] -> Format.pp_print_string fmt "{}"

     

       125
       125
       +
         | `O pairs ->

     

       126
       126
       +
             Format.fprintf fmt "@[<hv 2>{@,%a@]@,}"

     

       127
       127
       +
               (Format.pp_print_list ~pp_sep:(fun fmt () -> Format.fprintf fmt ",@ ")

     

       128
       128
       +
                  (fun fmt (k, v) -> Format.fprintf fmt "@[<hv 2>%S:@ %a@]" k pp v))

     

       129
       129
       +
               pairs

     

       130
       130
       +
       

     

       131
       131
       +
       (** Equality and comparison *)

     

       132
       132
       +
       

     

       133
       133
       +
       let rec equal (a : t) (b : t) =

     

       134
       134
       +
         match a, b with

     

       135
       135
       +
         | `Null, `Null -> true

     

       136
       136
       +
         | `Bool a, `Bool b -> a = b

     

       137
       137
       +
         | `Float a, `Float b -> Float.equal a b

     

       138
       138
       +
         | `String a, `String b -> String.equal a b

     

       139
       139
       +
         | `A a, `A b -> List.equal equal a b

     

       140
       140
       +
         | `O a, `O b ->

     

       141
       141
       +
             List.length a = List.length b &&

     

       142
       142
       +
             List.for_all2 (fun (k1, v1) (k2, v2) -> k1 = k2 && equal v1 v2) a b

     

       143
       143
       +
         | _ -> false

     

       144
       144
       +
       

     

       145
       145
       +
       let rec compare (a : t) (b : t) =

     

       146
       146
       +
         match a, b with

     

       147
       147
       +
         | `Null, `Null -> 0

     

       148
       148
       +
         | `Null, _ -> -1

     

       149
       149
       +
         | _, `Null -> 1

     

       150
       150
       +
         | `Bool a, `Bool b -> Bool.compare a b

     

       151
       151
       +
         | `Bool _, _ -> -1

     

       152
       152
       +
         | _, `Bool _ -> 1

     

       153
       153
       +
         | `Float a, `Float b -> Float.compare a b

     

       154
       154
       +
         | `Float _, _ -> -1

     

       155
       155
       +
         | _, `Float _ -> 1

     

       156
       156
       +
         | `String a, `String b -> String.compare a b

     

       157
       157
       +
         | `String _, _ -> -1

     

       158
       158
       +
         | _, `String _ -> 1

     

       159
       159
       +
         | `A a, `A b -> List.compare compare a b

     

       160
       160
       +
         | `A _, _ -> -1

     

       161
       161
       +
         | _, `A _ -> 1

     

       162
       162
       +
         | `O a, `O b ->

     

       163
       163
       +
             let cmp_pair (k1, v1) (k2, v2) =

     

       164
       164
       +
               let c = String.compare k1 k2 in

     

       165
       165
       +
               if c <> 0 then c else compare v1 v2

     

       166
       166
       +
             in

     

       167
       167
       +
             List.compare cmp_pair a b

+311

lib/yaml.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
       +
       (** Full YAML representation with anchors, tags, and aliases *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t = [

     

       9
       9
       +
         | `Scalar of Scalar.t

     

       10
       10
       +
         | `Alias of string

     

       11
       11
       +
         | `A of t Sequence.t

     

       12
       12
       +
         | `O of (t, t) Mapping.t

     

       13
       13
       +
       ]

     

       14
       14
       +
       

     

       15
       15
       +
       (** Pretty printing *)

     

       16
       16
       +
       

     

       17
       17
       +
       let rec pp fmt (v : t) =

     

       18
       18
       +
         match v with

     

       19
       19
       +
         | `Scalar s -> Scalar.pp fmt s

     

       20
       20
       +
         | `Alias name -> Format.fprintf fmt "*%s" name

     

       21
       21
       +
         | `A seq -> Sequence.pp pp fmt seq

     

       22
       22
       +
         | `O map -> Mapping.pp pp pp fmt map

     

       23
       23
       +
       

     

       24
       24
       +
       (** Equality *)

     

       25
       25
       +
       

     

       26
       26
       +
       let rec equal (a : t) (b : t) =

     

       27
       27
       +
         match a, b with

     

       28
       28
       +
         | `Scalar a, `Scalar b -> Scalar.equal a b

     

       29
       29
       +
         | `Alias a, `Alias b -> String.equal a b

     

       30
       30
       +
         | `A a, `A b -> Sequence.equal equal a b

     

       31
       31
       +
         | `O a, `O b -> Mapping.equal equal equal a b

     

       32
       32
       +
         | _ -> false

     

       33
       33
       +
       

     

       34
       34
       +
       (** Construct from JSON-compatible Value *)

     

       35
       35
       +
       

     

       36
       36
       +
       let rec of_value (v : Value.t) : t =

     

       37
       37
       +
         match v with

     

       38
       38
       +
         | `Null -> `Scalar (Scalar.make "null")

     

       39
       39
       +
         | `Bool true -> `Scalar (Scalar.make "true")

     

       40
       40
       +
         | `Bool false -> `Scalar (Scalar.make "false")

     

       41
       41
       +
         | `Float f ->

     

       42
       42
       +
             let s =

     

       43
       43
       +
               if Float.is_integer f && Float.abs f < 1e15 then

     

       44
       44
       +
                 Printf.sprintf "%.0f" f

     

       45
       45
       +
               else

     

       46
       46
       +
                 Printf.sprintf "%g" f

     

       47
       47
       +
             in

     

       48
       48
       +
             `Scalar (Scalar.make s)

     

       49
       49
       +
         | `String s ->

     

       50
       50
       +
             `Scalar (Scalar.make s ~style:`Double_quoted)

     

       51
       51
       +
         | `A items ->

     

       52
       52
       +
             `A (Sequence.make (List.map of_value items))

     

       53
       53
       +
         | `O pairs ->

     

       54
       54
       +
             `O (Mapping.make (List.map (fun (k, v) ->

     

       55
       55
       +
               (`Scalar (Scalar.make k), of_value v)

     

       56
       56
       +
             ) pairs))

     

       57
       57
       +
       

     

       58
       58
       +
       (** Default limits for alias expansion (protection against billion laughs attack) *)

     

       59
       59
       +
       let default_max_alias_nodes = 10_000_000

     

       60
       60
       +
       let default_max_alias_depth = 100

     

       61
       61
       +
       

     

       62
       62
       +
       (** Resolve aliases by replacing them with referenced nodes.

     

       63
       63
       +
       

     

       64
       64
       +
           Processes the tree in document order so that aliases resolve to the

     

       65
       65
       +
           anchor value that was defined at the point the alias was encountered.

     

       66
       66
       +
       

     

       67
       67
       +
           See {{:https://yaml.org/spec/1.2.2/#3222-anchors-and-aliases}Section 3.2.2.2

     

       68
       68
       +
           (Anchors and Aliases)} of the YAML 1.2.2 specification for details on

     

       69
       69
       +
           how anchors and aliases work in YAML.

     

       70
       70
       +
       

     

       71
       71
       +
           This implements protection against the "billion laughs attack"

     

       72
       72
       +
           (see {{:https://yaml.org/spec/1.2.2/#321-processes}Section 3.2.1 (Processes)})

     

       73
       73
       +
           by limiting both the total number of nodes and the nesting depth during expansion.

     

       74
       74
       +
       

     

       75
       75
       +
           @param max_nodes Maximum number of nodes to create during expansion (default 10M)

     

       76
       76
       +
           @param max_depth Maximum depth of alias-within-alias resolution (default 100)

     

       77
       77
       +
           @raise Error.Yamlrw_error with {!type:Error.kind} [Alias_expansion_node_limit] if max_nodes is exceeded

     

       78
       78
       +
           @raise Error.Yamlrw_error with {!type:Error.kind} [Alias_expansion_depth_limit] if max_depth is exceeded

     

       79
       79
       +
       *)

     

       80
       80
       +
       let resolve_aliases ?(max_nodes = default_max_alias_nodes) ?(max_depth = default_max_alias_depth) (root : t) : t =

     

       81
       81
       +
         let anchors = Hashtbl.create 16 in

     

       82
       82
       +
         let node_count = ref 0 in

     

       83
       83
       +
       

     

       84
       84
       +
         (* Check node limit *)

     

       85
       85
       +
         let check_node_limit () =

     

       86
       86
       +
           incr node_count;

     

       87
       87
       +
           if !node_count > max_nodes then

     

       88
       88
       +
             Error.raise (Alias_expansion_node_limit max_nodes)

     

       89
       89
       +
         in

     

       90
       90
       +
       

     

       91
       91
       +
         (* Register anchor if present on a node *)

     

       92
       92
       +
         let register_anchor name resolved_node =

     

       93
       93
       +
           Hashtbl.replace anchors name resolved_node

     

       94
       94
       +
         in

     

       95
       95
       +
       

     

       96
       96
       +
         (* Resolve an alias by looking up and expanding the target *)

     

       97
       97
       +
         let rec expand_alias ~depth name =

     

       98
       98
       +
           if depth >= max_depth then

     

       99
       99
       +
             Error.raise (Alias_expansion_depth_limit max_depth);

     

       100
       100
       +
           match Hashtbl.find_opt anchors name with

     

       101
       101
       +
           | Some target ->

     

       102
       102
       +
               (* The target is already resolved, but may contain aliases that

     

       103
       103
       +
                  need expansion if it was registered before those anchors existed *)

     

       104
       104
       +
               resolve ~depth:(depth + 1) target

     

       105
       105
       +
           | None -> Error.raise (Undefined_alias name)

     

       106
       106
       +
       

     

       107
       107
       +
         (* Single pass: process in document order, registering anchors and resolving aliases *)

     

       108
       108
       +
         and resolve ~depth (v : t) : t =

     

       109
       109
       +
           check_node_limit ();

     

       110
       110
       +
           match v with

     

       111
       111
       +
           | `Scalar s ->

     

       112
       112
       +
               (* Register anchor after we have the resolved node *)

     

       113
       113
       +
               (match Scalar.anchor s with

     

       114
       114
       +
                | Some name -> register_anchor name v

     

       115
       115
       +
                | None -> ());

     

       116
       116
       +
               v

     

       117
       117
       +
           | `Alias name ->

     

       118
       118
       +
               expand_alias ~depth name

     

       119
       119
       +
           | `A seq ->

     

       120
       120
       +
               (* First resolve all members in order *)

     

       121
       121
       +
               let resolved_members = List.map (resolve ~depth) (Sequence.members seq) in

     

       122
       122
       +
               let resolved = `A (Sequence.make

     

       123
       123
       +
                 ?anchor:(Sequence.anchor seq)

     

       124
       124
       +
                 ?tag:(Sequence.tag seq)

     

       125
       125
       +
                 ~implicit:(Sequence.implicit seq)

     

       126
       126
       +
                 ~style:(Sequence.style seq)

     

       127
       127
       +
                 resolved_members) in

     

       128
       128
       +
               (* Register anchor with resolved node *)

     

       129
       129
       +
               (match Sequence.anchor seq with

     

       130
       130
       +
                | Some name -> register_anchor name resolved

     

       131
       131
       +
                | None -> ());

     

       132
       132
       +
               resolved

     

       133
       133
       +
           | `O map ->

     

       134
       134
       +
               (* Process key-value pairs in document order *)

     

       135
       135
       +
               let resolved_pairs = List.map (fun (k, v) ->

     

       136
       136
       +
                 let resolved_k = resolve ~depth k in

     

       137
       137
       +
                 let resolved_v = resolve ~depth v in

     

       138
       138
       +
                 (resolved_k, resolved_v)

     

       139
       139
       +
               ) (Mapping.members map) in

     

       140
       140
       +
               let resolved = `O (Mapping.make

     

       141
       141
       +
                 ?anchor:(Mapping.anchor map)

     

       142
       142
       +
                 ?tag:(Mapping.tag map)

     

       143
       143
       +
                 ~implicit:(Mapping.implicit map)

     

       144
       144
       +
                 ~style:(Mapping.style map)

     

       145
       145
       +
                 resolved_pairs) in

     

       146
       146
       +
               (* Register anchor with resolved node *)

     

       147
       147
       +
               (match Mapping.anchor map with

     

       148
       148
       +
                | Some name -> register_anchor name resolved

     

       149
       149
       +
                | None -> ());

     

       150
       150
       +
               resolved

     

       151
       151
       +
         in

     

       152
       152
       +
         resolve ~depth:0 root

     

       153
       153
       +
       

     

       154
       154
       +
       (** Convert scalar to JSON value based on content *)

     

       155
       155
       +
       let rec scalar_to_value s =

     

       156
       156
       +
         let value = Scalar.value s in

     

       157
       157
       +
         let tag = Scalar.tag s in

     

       158
       158
       +
         let style = Scalar.style s in

     

       159
       159
       +
       

     

       160
       160
       +
         (* If explicitly tagged, respect the tag *)

     

       161
       161
       +
         match tag with

     

       162
       162
       +
         | Some "tag:yaml.org,2002:null" | Some "!!null" ->

     

       163
       163
       +
             `Null

     

       164
       164
       +
         | Some "tag:yaml.org,2002:bool" | Some "!!bool" ->

     

       165
       165
       +
             (match String.lowercase_ascii value with

     

       166
       166
       +
              | "true" | "yes" | "on" -> `Bool true

     

       167
       167
       +
              | "false" | "no" | "off" -> `Bool false

     

       168
       168
       +
              | _ -> Error.raise (Invalid_scalar_conversion (value, "bool")))

     

       169
       169
       +
         | Some "tag:yaml.org,2002:int" | Some "!!int" ->

     

       170
       170
       +
             (try `Float (Float.of_string value)

     

       171
       171
       +
              with _ -> Error.raise (Invalid_scalar_conversion (value, "int")))

     

       172
       172
       +
         | Some "tag:yaml.org,2002:float" | Some "!!float" ->

     

       173
       173
       +
             (try `Float (Float.of_string value)

     

       174
       174
       +
              with _ -> Error.raise (Invalid_scalar_conversion (value, "float")))

     

       175
       175
       +
         | Some "tag:yaml.org,2002:str" | Some "!!str" ->

     

       176
       176
       +
             `String value

     

       177
       177
       +
         | Some _ ->

     

       178
       178
       +
             (* Unknown tag - treat as string *)

     

       179
       179
       +
             `String value

     

       180
       180
       +
         | None ->

     

       181
       181
       +
             (* Implicit type resolution for plain scalars *)

     

       182
       182
       +
             if style <> `Plain then

     

       183
       183
       +
               `String value

     

       184
       184
       +
             else

     

       185
       185
       +
               infer_scalar_type value

     

       186
       186
       +
       

     

       187
       187
       +
       (** Infer type from plain scalar value *)

     

       188
       188
       +
       and infer_scalar_type value =

     

       189
       189
       +
         match String.lowercase_ascii value with

     

       190
       190
       +
         (* Null *)

     

       191
       191
       +
         | "" | "null" | "~" -> `Null

     

       192
       192
       +
         (* Boolean true *)

     

       193
       193
       +
         | "true" | "yes" | "on" -> `Bool true

     

       194
       194
       +
         (* Boolean false *)

     

       195
       195
       +
         | "false" | "no" | "off" -> `Bool false

     

       196
       196
       +
         (* Special floats *)

     

       197
       197
       +
         | ".inf" | "+.inf" -> `Float Float.infinity

     

       198
       198
       +
         | "-.inf" -> `Float Float.neg_infinity

     

       199
       199
       +
         | ".nan" -> `Float Float.nan

     

       200
       200
       +
         (* Try numeric *)

     

       201
       201
       +
         | _ -> try_parse_number value

     

       202
       202
       +
       

     

       203
       203
       +
       (** Try to parse as number *)

     

       204
       204
       +
       and try_parse_number value =

     

       205
       205
       +
         (* Check if value looks like a valid YAML number (not inf/nan without dot)

     

       206
       206
       +
            This guards against OCaml's Float.of_string accepting "inf", "nan", etc.

     

       207
       207
       +
            See: https://github.com/avsm/ocaml-yaml/issues/82 *)

     

       208
       208
       +
         let looks_like_number () =

     

       209
       209
       +
           let len = String.length value in

     

       210
       210
       +
           if len = 0 then false

     

       211
       211
       +
           else

     

       212
       212
       +
             let first = value.[0] in

     

       213
       213
       +
             if first >= '0' && first <= '9' then true

     

       214
       214
       +
             else if (first = '-' || first = '+') && len >= 2 then

     

       215
       215
       +
               let second = value.[1] in

     

       216
       216
       +
               (* After sign, must be digit or dot-digit (for +.5, -.5) *)

     

       217
       217
       +
               second >= '0' && second <= '9' ||

     

       218
       218
       +
               (second = '.' && len >= 3 && value.[2] >= '0' && value.[2] <= '9')

     

       219
       219
       +
             else false

     

       220
       220
       +
         in

     

       221
       221
       +
         (* Try integer/float *)

     

       222
       222
       +
         let try_numeric () =

     

       223
       223
       +
           if looks_like_number () then

     

       224
       224
       +
             try

     

       225
       225
       +
               (* Handle octal: 0o prefix or leading 0 *)

     

       226
       226
       +
               if String.length value > 2 && value.[0] = '0' then

     

       227
       227
       +
                 match value.[1] with

     

       228
       228
       +
                 | 'x' | 'X' ->

     

       229
       229
       +
                     (* Hex *)

     

       230
       230
       +
                     Some (`Float (Float.of_int (int_of_string value)))

     

       231
       231
       +
                 | 'o' | 'O' ->

     

       232
       232
       +
                     (* Octal *)

     

       233
       233
       +
                     Some (`Float (Float.of_int (int_of_string value)))

     

       234
       234
       +
                 | 'b' | 'B' ->

     

       235
       235
       +
                     (* Binary *)

     

       236
       236
       +
                     Some (`Float (Float.of_int (int_of_string value)))

     

       237
       237
       +
                 | _ ->

     

       238
       238
       +
                     (* Decimal with leading zero or octal in YAML 1.1 *)

     

       239
       239
       +
                     Some (`Float (Float.of_string value))

     

       240
       240
       +
               else

     

       241
       241
       +
                 Some (`Float (Float.of_string value))

     

       242
       242
       +
             with _ -> None

     

       243
       243
       +
           else None

     

       244
       244
       +
         in

     

       245
       245
       +
         match try_numeric () with

     

       246
       246
       +
         | Some v -> v

     

       247
       247
       +
         | None ->

     

       248
       248
       +
             (* Try float starting with dot (e.g., .5 for 0.5)

     

       249
       249
       +
                Note: We must NOT use Float.of_string as a general fallback because

     

       250
       250
       +
                OCaml accepts "nan", "inf", "infinity" which are NOT valid YAML floats.

     

       251
       251
       +
                YAML requires the leading dot: .nan, .inf, -.inf

     

       252
       252
       +
                See: https://github.com/avsm/ocaml-yaml/issues/82 *)

     

       253
       253
       +
             if String.length value >= 2 && value.[0] = '.' &&

     

       254
       254
       +
                value.[1] >= '0' && value.[1] <= '9' then

     

       255
       255
       +
               try `Float (Float.of_string value)

     

       256
       256
       +
               with _ -> `String value

     

       257
       257
       +
             else

     

       258
       258
       +
               `String value

     

       259
       259
       +
       

     

       260
       260
       +
       (** Convert to JSON-compatible Value.

     

       261
       261
       +
       

     

       262
       262
       +
           Converts a full YAML representation to a simplified JSON-compatible value type.

     

       263
       263
       +
           This process implements the representation graph to serialization tree conversion

     

       264
       264
       +
           described in {{:https://yaml.org/spec/1.2.2/#32-processes}Section 3.2 (Processes)}

     

       265
       265
       +
           of the YAML 1.2.2 specification.

     

       266
       266
       +
       

     

       267
       267
       +
           See also {{:https://yaml.org/spec/1.2.2/#10212-json-schema}Section 10.2.1.2

     

       268
       268
       +
           (JSON Schema)} for the tag resolution used during conversion.

     

       269
       269
       +
       

     

       270
       270
       +
           @param resolve_aliases_first Whether to resolve aliases before conversion (default true)

     

       271
       271
       +
           @param max_nodes Maximum nodes during alias expansion (default 10M)

     

       272
       272
       +
           @param max_depth Maximum alias nesting depth (default 100)

     

       273
       273
       +
           @raise Error.Yamlrw_error with {!type:Error.kind} [Unresolved_alias] if resolve_aliases_first is false and an alias is encountered

     

       274
       274
       +
       *)

     

       275
       275
       +
       let to_value

     

       276
       276
       +
           ?(resolve_aliases_first = true)

     

       277
       277
       +
           ?(max_nodes = default_max_alias_nodes)

     

       278
       278
       +
           ?(max_depth = default_max_alias_depth)

     

       279
       279
       +
           (v : t) : Value.t =

     

       280
       280
       +
         let v = if resolve_aliases_first then resolve_aliases ~max_nodes ~max_depth v else v in

     

       281
       281
       +
         let rec convert (v : t) : Value.t =

     

       282
       282
       +
           match v with

     

       283
       283
       +
           | `Scalar s -> scalar_to_value s

     

       284
       284
       +
           | `Alias name -> Error.raise (Unresolved_alias name)

     

       285
       285
       +
           | `A seq -> `A (List.map convert (Sequence.members seq))

     

       286
       286
       +
           | `O map ->

     

       287
       287
       +
               `O (List.map (fun (k, v) ->

     

       288
       288
       +
                 let key = match k with

     

       289
       289
       +
                   | `Scalar s -> Scalar.value s

     

       290
       290
       +
                   | _ -> Error.raise (Type_mismatch ("string key", "complex key"))

     

       291
       291
       +
                 in

     

       292
       292
       +
                 (key, convert v)

     

       293
       293
       +
               ) (Mapping.members map))

     

       294
       294
       +
         in

     

       295
       295
       +
         convert v

     

       296
       296
       +
       

     

       297
       297
       +
       (** Get anchor from any node *)

     

       298
       298
       +
       let anchor (v : t) =

     

       299
       299
       +
         match v with

     

       300
       300
       +
         | `Scalar s -> Scalar.anchor s

     

       301
       301
       +
         | `Alias _ -> None

     

       302
       302
       +
         | `A seq -> Sequence.anchor seq

     

       303
       303
       +
         | `O map -> Mapping.anchor map

     

       304
       304
       +
       

     

       305
       305
       +
       (** Get tag from any node *)

     

       306
       306
       +
       let tag (v : t) =

     

       307
       307
       +
         match v with

     

       308
       308
       +
         | `Scalar s -> Scalar.tag s

     

       309
       309
       +
         | `Alias _ -> None

     

       310
       310
       +
         | `A seq -> Sequence.tag seq

     

       311
       311
       +
         | `O map -> Mapping.tag map

+700

lib/yamlrw.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
       +
       (** {1 Yamlrw - A Pure OCaml YAML Parser and Emitter} *)

     

       7
       7
       +
       

     

       8
       8
       +
       (** {2 Error Handling} *)

     

       9
       9
       +
       

     

       10
       10
       +
       module Error = Error

     

       11
       11
       +
       

     

       12
       12
       +
       exception Yamlrw_error = Error.Yamlrw_error

     

       13
       13
       +
       

     

       14
       14
       +
       

     

       15
       15
       +
       (** {2 Core Types} *)

     

       16
       16
       +
       

     

       17
       17
       +
       (** JSON-compatible YAML representation. Use this for simple data interchange.

     

       18
       18
       +
       

     

       19
       19
       +
           This type is structurally equivalent to {!Value.t} and compatible with the

     

       20
       20
       +
           ezjsonm representation. For additional operations, see {!Value} and {!Util}. *)

     

       21
       21
       +
       type value = [

     

       22
       22
       +
         | `Null                      (** YAML null, ~, or empty values *)

     

       23
       23
       +
         | `Bool of bool              (** YAML booleans (true, false, yes, no, on, off) *)

     

       24
       24
       +
         | `Float of float            (** All YAML numbers (integers stored as floats) *)

     

       25
       25
       +
         | `String of string          (** YAML strings *)

     

       26
       26
       +
         | `A of value list           (** YAML sequences/arrays *)

     

       27
       27
       +
         | `O of (string * value) list (** YAML mappings/objects with string keys *)

     

       28
       28
       +
       ]

     

       29
       29
       +
       

     

       30
       30
       +
       (** Full YAML representation preserving anchors, tags, and aliases.

     

       31
       31
       +
       

     

       32
       32
       +
           This type is structurally equivalent to {!Yaml.t}. Use this when you need

     

       33
       33
       +
           access to YAML-specific features like anchors and aliases for node reuse,

     

       34
       34
       +
           type tags for custom types, scalar styles (plain, quoted, literal, folded),

     

       35
       35
       +
           and collection styles (block vs flow).

     

       36
       36
       +
       

     

       37
       37
       +
           For additional operations, see {!Yaml}, {!Scalar}, {!Sequence}, and {!Mapping}. *)

     

       38
       38
       +
       type yaml = [

     

       39
       39
       +
         | `Scalar of Scalar.t      (** YAML scalar value with style and metadata *)

     

       40
       40
       +
         | `Alias of string         (** Alias reference to an anchored node *)

     

       41
       41
       +
         | `A of yaml Sequence.t    (** YAML sequence with style and metadata *)

     

       42
       42
       +
         | `O of (yaml, yaml) Mapping.t (** YAML mapping with style and metadata *)

     

       43
       43
       +
       ]

     

       44
       44
       +
       

     

       45
       45
       +
       (** A YAML document with directives and metadata.

     

       46
       46
       +
       

     

       47
       47
       +
           This type is structurally equivalent to {!Document.t}. A YAML stream can

     

       48
       48
       +
           contain multiple documents, each separated by document markers.

     

       49
       49
       +
       

     

       50
       50
       +
           For additional operations, see {!Document}. *)

     

       51
       51
       +
       type document = {

     

       52
       52
       +
         version : (int * int) option;        (** Optional YAML version directive (e.g., (1, 2) for YAML 1.2) *)

     

       53
       53
       +
         tags : (string * string) list;       (** TAG directives mapping handles to prefixes *)

     

       54
       54
       +
         root : yaml option;                  (** Root content of the document *)

     

       55
       55
       +
         implicit_start : bool;               (** Whether the document start marker (---) is implicit *)

     

       56
       56
       +
         implicit_end : bool;                 (** Whether the document end marker (...) is implicit *)

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       

     

       60
       60
       +
       (** {2 Character Encoding} *)

     

       61
       61
       +
       

     

       62
       62
       +
       module Encoding = Encoding

     

       63
       63
       +
       

     

       64
       64
       +
       

     

       65
       65
       +
       (** {2 Parsing} *)

     

       66
       66
       +
       

     

       67
       67
       +
       type version = [ `V1_1 | `V1_2 ]

     

       68
       68
       +
       

     

       69
       69
       +
       (** Default maximum nodes during alias expansion (10 million). *)

     

       70
       70
       +
       let default_max_alias_nodes = Yaml.default_max_alias_nodes

     

       71
       71
       +
       

     

       72
       72
       +
       (** Default maximum alias nesting depth (100). *)

     

       73
       73
       +
       let default_max_alias_depth = Yaml.default_max_alias_depth

     

       74
       74
       +
       

     

       75
       75
       +
       let of_string

     

       76
       76
       +
           ?(resolve_aliases = true)

     

       77
       77
       +
           ?(max_nodes = default_max_alias_nodes)

     

       78
       78
       +
           ?(max_depth = default_max_alias_depth)

     

       79
       79
       +
           s : value =

     

       80
       80
       +
         (Loader.value_of_string ~resolve_aliases ~max_nodes ~max_depth s :> value)

     

       81
       81
       +
       (** Parse a YAML string into a JSON-compatible value.

     

       82
       82
       +
       

     

       83
       83
       +
           @param resolve_aliases Whether to expand aliases (default: true)

     

       84
       84
       +
           @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       85
       85
       +
           @param max_depth Maximum alias nesting depth (default: 100)

     

       86
       86
       +
           @raise Yamlrw_error on parse error or if multiple documents found *)

     

       87
       87
       +
       

     

       88
       88
       +
       let yaml_of_string

     

       89
       89
       +
           ?(resolve_aliases = false)

     

       90
       90
       +
           ?(max_nodes = default_max_alias_nodes)

     

       91
       91
       +
           ?(max_depth = default_max_alias_depth)

     

       92
       92
       +
           s : yaml =

     

       93
       93
       +
         (Loader.yaml_of_string ~resolve_aliases ~max_nodes ~max_depth s :> yaml)

     

       94
       94
       +
       (** Parse a YAML string preserving full YAML metadata (anchors, tags, etc).

     

       95
       95
       +
       

     

       96
       96
       +
           By default, aliases are NOT resolved, preserving the document structure.

     

       97
       97
       +
       

     

       98
       98
       +
           @param resolve_aliases Whether to expand aliases (default: false)

     

       99
       99
       +
           @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       100
       100
       +
           @param max_depth Maximum alias nesting depth (default: 100)

     

       101
       101
       +
           @raise Yamlrw_error on parse error or if multiple documents found *)

     

       102
       102
       +
       

     

       103
       103
       +
       let documents_of_string s : document list =

     

       104
       104
       +
         let docs = Loader.documents_of_string s in

     

       105
       105
       +
         List.map (fun (d : Document.t) : document -> {

     

       106
       106
       +
           version = d.version;

     

       107
       107
       +
           tags = d.tags;

     

       108
       108
       +
           root = (d.root :> yaml option);

     

       109
       109
       +
           implicit_start = d.implicit_start;

     

       110
       110
       +
           implicit_end = d.implicit_end;

     

       111
       111
       +
         }) docs

     

       112
       112
       +
       (** Parse a multi-document YAML stream.

     

       113
       113
       +
       

     

       114
       114
       +
           Use this when your YAML input contains multiple documents separated

     

       115
       115
       +
           by document markers (---).

     

       116
       116
       +
       

     

       117
       117
       +
           @raise Yamlrw_error on parse error *)

     

       118
       118
       +
       

     

       119
       119
       +
       

     

       120
       120
       +
       (** {2 Formatting Styles} *)

     

       121
       121
       +
       

     

       122
       122
       +
       module Scalar_style = Scalar_style

     

       123
       123
       +
       

     

       124
       124
       +
       module Layout_style = Layout_style

     

       125
       125
       +
       

     

       126
       126
       +
       

     

       127
       127
       +
       (** {2 Serialization} *)

     

       128
       128
       +
       

     

       129
       129
       +
       let make_config ~encoding ~scalar_style ~layout_style =

     

       130
       130
       +
         { Emitter.default_config with encoding; scalar_style; layout_style }

     

       131
       131
       +
       

     

       132
       132
       +
       let to_buffer

     

       133
       133
       +
           ?(encoding = `Utf8)

     

       134
       134
       +
           ?(scalar_style = `Any)

     

       135
       135
       +
           ?(layout_style = `Any)

     

       136
       136
       +
           ?buffer

     

       137
       137
       +
           (value : value) =

     

       138
       138
       +
         let config = make_config ~encoding ~scalar_style ~layout_style in

     

       139
       139
       +
         Serialize.value_to_buffer ~config ?buffer (value :> Value.t)

     

       140
       140
       +
       (** Serialize a value to a buffer.

     

       141
       141
       +
       

     

       142
       142
       +
           @param encoding Output encoding (default: UTF-8)

     

       143
       143
       +
           @param scalar_style Preferred scalar style (default: Any)

     

       144
       144
       +
           @param layout_style Preferred layout style (default: Any)

     

       145
       145
       +
           @param buffer Optional buffer to append to (allocates new one if not provided)

     

       146
       146
       +
           @return The buffer containing the serialized YAML *)

     

       147
       147
       +
       

     

       148
       148
       +
       let to_string

     

       149
       149
       +
           ?(encoding = `Utf8)

     

       150
       150
       +
           ?(scalar_style = `Any)

     

       151
       151
       +
           ?(layout_style = `Any)

     

       152
       152
       +
           (value : value) =

     

       153
       153
       +
         Buffer.contents (to_buffer ~encoding ~scalar_style ~layout_style value)

     

       154
       154
       +
       (** Serialize a value to a YAML string.

     

       155
       155
       +
       

     

       156
       156
       +
           @param encoding Output encoding (default: UTF-8)

     

       157
       157
       +
           @param scalar_style Preferred scalar style (default: Any)

     

       158
       158
       +
           @param layout_style Preferred layout style (default: Any) *)

     

       159
       159
       +
       

     

       160
       160
       +
       let yaml_to_buffer

     

       161
       161
       +
           ?(encoding = `Utf8)

     

       162
       162
       +
           ?(scalar_style = `Any)

     

       163
       163
       +
           ?(layout_style = `Any)

     

       164
       164
       +
           ?buffer

     

       165
       165
       +
           (yaml : yaml) =

     

       166
       166
       +
         let config = make_config ~encoding ~scalar_style ~layout_style in

     

       167
       167
       +
         Serialize.yaml_to_buffer ~config ?buffer (yaml :> Yaml.t)

     

       168
       168
       +
       (** Serialize a full YAML value to a buffer.

     

       169
       169
       +
       

     

       170
       170
       +
           @param encoding Output encoding (default: UTF-8)

     

       171
       171
       +
           @param scalar_style Preferred scalar style (default: Any)

     

       172
       172
       +
           @param layout_style Preferred layout style (default: Any)

     

       173
       173
       +
           @param buffer Optional buffer to append to (allocates new one if not provided)

     

       174
       174
       +
           @return The buffer containing the serialized YAML *)

     

       175
       175
       +
       

     

       176
       176
       +
       let yaml_to_string

     

       177
       177
       +
           ?(encoding = `Utf8)

     

       178
       178
       +
           ?(scalar_style = `Any)

     

       179
       179
       +
           ?(layout_style = `Any)

     

       180
       180
       +
           (yaml : yaml) =

     

       181
       181
       +
         Buffer.contents (yaml_to_buffer ~encoding ~scalar_style ~layout_style yaml)

     

       182
       182
       +
       (** Serialize a full YAML value to a string.

     

       183
       183
       +
       

     

       184
       184
       +
           @param encoding Output encoding (default: UTF-8)

     

       185
       185
       +
           @param scalar_style Preferred scalar style (default: Any)

     

       186
       186
       +
           @param layout_style Preferred layout style (default: Any) *)

     

       187
       187
       +
       

     

       188
       188
       +
       let documents_to_buffer

     

       189
       189
       +
           ?(encoding = `Utf8)

     

       190
       190
       +
           ?(scalar_style = `Any)

     

       191
       191
       +
           ?(layout_style = `Any)

     

       192
       192
       +
           ?(resolve_aliases = true)

     

       193
       193
       +
           ?buffer

     

       194
       194
       +
           (documents : document list) =

     

       195
       195
       +
         let config = make_config ~encoding ~scalar_style ~layout_style in

     

       196
       196
       +
         let docs' = List.map (fun (d : document) : Document.t -> {

     

       197
       197
       +
           Document.version = d.version;

     

       198
       198
       +
           Document.tags = d.tags;

     

       199
       199
       +
           Document.root = (d.root :> Yaml.t option);

     

       200
       200
       +
           Document.implicit_start = d.implicit_start;

     

       201
       201
       +
           Document.implicit_end = d.implicit_end;

     

       202
       202
       +
         }) documents in

     

       203
       203
       +
         Serialize.documents_to_buffer ~config ~resolve_aliases ?buffer docs'

     

       204
       204
       +
       (** Serialize multiple documents to a buffer.

     

       205
       205
       +
       

     

       206
       206
       +
           @param encoding Output encoding (default: UTF-8)

     

       207
       207
       +
           @param scalar_style Preferred scalar style (default: Any)

     

       208
       208
       +
           @param layout_style Preferred layout style (default: Any)

     

       209
       209
       +
           @param resolve_aliases Whether to expand aliases (default: true)

     

       210
       210
       +
           @param buffer Optional buffer to append to (allocates new one if not provided)

     

       211
       211
       +
           @return The buffer containing the serialized YAML *)

     

       212
       212
       +
       

     

       213
       213
       +
       let documents_to_string

     

       214
       214
       +
           ?(encoding = `Utf8)

     

       215
       215
       +
           ?(scalar_style = `Any)

     

       216
       216
       +
           ?(layout_style = `Any)

     

       217
       217
       +
           ?(resolve_aliases = true)

     

       218
       218
       +
           (documents : document list) =

     

       219
       219
       +
         Buffer.contents (documents_to_buffer ~encoding ~scalar_style ~layout_style ~resolve_aliases documents)

     

       220
       220
       +
       (** Serialize multiple documents to a YAML stream.

     

       221
       221
       +
       

     

       222
       222
       +
           @param encoding Output encoding (default: UTF-8)

     

       223
       223
       +
           @param scalar_style Preferred scalar style (default: Any)

     

       224
       224
       +
           @param layout_style Preferred layout style (default: Any)

     

       225
       225
       +
           @param resolve_aliases Whether to expand aliases (default: true) *)

     

       226
       226
       +
       

     

       227
       227
       +
       (** {2 Buffer Parsing} *)

     

       228
       228
       +
       

     

       229
       229
       +
       let of_buffer

     

       230
       230
       +
           ?(resolve_aliases = true)

     

       231
       231
       +
           ?(max_nodes = default_max_alias_nodes)

     

       232
       232
       +
           ?(max_depth = default_max_alias_depth)

     

       233
       233
       +
           buffer : value =

     

       234
       234
       +
         of_string ~resolve_aliases ~max_nodes ~max_depth (Buffer.contents buffer)

     

       235
       235
       +
       (** Parse YAML from a buffer into a JSON-compatible value.

     

       236
       236
       +
       

     

       237
       237
       +
           @param resolve_aliases Whether to expand aliases (default: true)

     

       238
       238
       +
           @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       239
       239
       +
           @param max_depth Maximum alias nesting depth (default: 100)

     

       240
       240
       +
           @raise Yamlrw_error on parse error or if multiple documents found *)

     

       241
       241
       +
       

     

       242
       242
       +
       let yaml_of_buffer

     

       243
       243
       +
           ?(resolve_aliases = false)

     

       244
       244
       +
           ?(max_nodes = default_max_alias_nodes)

     

       245
       245
       +
           ?(max_depth = default_max_alias_depth)

     

       246
       246
       +
           buffer : yaml =

     

       247
       247
       +
         yaml_of_string ~resolve_aliases ~max_nodes ~max_depth (Buffer.contents buffer)

     

       248
       248
       +
       (** Parse YAML from a buffer preserving full YAML metadata.

     

       249
       249
       +
       

     

       250
       250
       +
           @param resolve_aliases Whether to expand aliases (default: false)

     

       251
       251
       +
           @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       252
       252
       +
           @param max_depth Maximum alias nesting depth (default: 100)

     

       253
       253
       +
           @raise Yamlrw_error on parse error or if multiple documents found *)

     

       254
       254
       +
       

     

       255
       255
       +
       let documents_of_buffer buffer : document list =

     

       256
       256
       +
         documents_of_string (Buffer.contents buffer)

     

       257
       257
       +
       (** Parse a multi-document YAML stream from a buffer.

     

       258
       258
       +
       

     

       259
       259
       +
           @raise Yamlrw_error on parse error *)

     

       260
       260
       +
       

     

       261
       261
       +
       

     

       262
       262
       +
       (** {2 Conversion} *)

     

       263
       263
       +
       

     

       264
       264
       +
       let to_json

     

       265
       265
       +
           ?(resolve_aliases = true)

     

       266
       266
       +
           ?(max_nodes = default_max_alias_nodes)

     

       267
       267
       +
           ?(max_depth = default_max_alias_depth)

     

       268
       268
       +
           (yaml : yaml) : value =

     

       269
       269
       +
         (Yaml.to_value ~resolve_aliases_first:resolve_aliases ~max_nodes ~max_depth (yaml :> Yaml.t) :> value)

     

       270
       270
       +
       (** Convert full YAML to JSON-compatible value.

     

       271
       271
       +
       

     

       272
       272
       +
           @param resolve_aliases Whether to expand aliases (default: true)

     

       273
       273
       +
           @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       274
       274
       +
           @param max_depth Maximum alias nesting depth (default: 100)

     

       275
       275
       +
           @raise Yamlrw_error if alias limits exceeded or complex keys found *)

     

       276
       276
       +
       

     

       277
       277
       +
       let of_json (value : value) : yaml =

     

       278
       278
       +
         (Yaml.of_value (value :> Value.t) :> yaml)

     

       279
       279
       +
       (** Convert JSON-compatible value to full YAML representation. *)

     

       280
       280
       +
       

     

       281
       281
       +
       

     

       282
       282
       +
       (** {2 Pretty Printing & Equality} *)

     

       283
       283
       +
       

     

       284
       284
       +
       let pp = Value.pp

     

       285
       285
       +
       (** Pretty-print a value. *)

     

       286
       286
       +
       

     

       287
       287
       +
       let equal = Value.equal

     

       288
       288
       +
       (** Test equality of two values. *)

     

       289
       289
       +
       

     

       290
       290
       +
       

     

       291
       291
       +
       (** {2 Util - Value Combinators} *)

     

       292
       292
       +
       

     

       293
       293
       +
       module Util = struct

     

       294
       294
       +
         (** Combinators for working with {!type:value} values.

     

       295
       295
       +
       

     

       296
       296
       +
             This module provides constructors, accessors, and transformations

     

       297
       297
       +
             for JSON-compatible YAML values. *)

     

       298
       298
       +
       

     

       299
       299
       +
         type t = Value.t

     

       300
       300
       +
       

     

       301
       301
       +
         (** {3 Type Error} *)

     

       302
       302
       +
       

     

       303
       303
       +
         exception Type_error of string * t

     

       304
       304
       +
         (** Raised when a value has unexpected type.

     

       305
       305
       +
             [Type_error (expected, actual_value)] *)

     

       306
       306
       +
       

     

       307
       307
       +
         let type_error expected v = raise (Type_error (expected, v))

     

       308
       308
       +
       

     

       309
       309
       +
         (** {3 Constructors} *)

     

       310
       310
       +
       

     

       311
       311
       +
         let null : t = `Null

     

       312
       312
       +
         let bool b : t = `Bool b

     

       313
       313
       +
         let int n : t = `Float (Float.of_int n)

     

       314
       314
       +
         let float f : t = `Float f

     

       315
       315
       +
         let string s : t = `String s

     

       316
       316
       +
         let strings ss : t = `A (List.map (fun s -> `String s) ss)

     

       317
       317
       +
         let list vs : t = `A vs

     

       318
       318
       +
         let obj pairs : t = `O pairs

     

       319
       319
       +
       

     

       320
       320
       +
         (** {3 Type Predicates} *)

     

       321
       321
       +
       

     

       322
       322
       +
         let is_null = function `Null -> true | _ -> false

     

       323
       323
       +
         let is_bool = function `Bool _ -> true | _ -> false

     

       324
       324
       +
         let is_number = function `Float _ -> true | _ -> false

     

       325
       325
       +
         let is_string = function `String _ -> true | _ -> false

     

       326
       326
       +
         let is_list = function `A _ -> true | _ -> false

     

       327
       327
       +
         let is_obj = function `O _ -> true | _ -> false

     

       328
       328
       +
       

     

       329
       329
       +
         (** {3 Safe Accessors} *)

     

       330
       330
       +
       

     

       331
       331
       +
         let as_null = function `Null -> Some () | _ -> None

     

       332
       332
       +
         let as_bool = function `Bool b -> Some b | _ -> None

     

       333
       333
       +
         let as_float = function `Float f -> Some f | _ -> None

     

       334
       334
       +
         let as_string = function `String s -> Some s | _ -> None

     

       335
       335
       +
         let as_list = function `A l -> Some l | _ -> None

     

       336
       336
       +
         let as_obj = function `O o -> Some o | _ -> None

     

       337
       337
       +
       

     

       338
       338
       +
         let as_int = function

     

       339
       339
       +
           | `Float f ->

     

       340
       340
       +
               let i = Float.to_int f in

     

       341
       341
       +
               if Float.equal (Float.of_int i) f then Some i else None

     

       342
       342
       +
           | _ -> None

     

       343
       343
       +
       

     

       344
       344
       +
         (** {3 Unsafe Accessors} *)

     

       345
       345
       +
       

     

       346
       346
       +
         let get_null v = match v with `Null -> () | _ -> type_error "null" v

     

       347
       347
       +
         let get_bool v = match v with `Bool b -> b | _ -> type_error "bool" v

     

       348
       348
       +
         let get_float v = match v with `Float f -> f | _ -> type_error "float" v

     

       349
       349
       +
         let get_string v = match v with `String s -> s | _ -> type_error "string" v

     

       350
       350
       +
         let get_list v = match v with `A l -> l | _ -> type_error "list" v

     

       351
       351
       +
         let get_obj v = match v with `O o -> o | _ -> type_error "object" v

     

       352
       352
       +
       

     

       353
       353
       +
         let get_int v =

     

       354
       354
       +
           match as_int v with

     

       355
       355
       +
           | Some i -> i

     

       356
       356
       +
           | None -> type_error "int" v

     

       357
       357
       +
       

     

       358
       358
       +
         (** {3 Object Operations} *)

     

       359
       359
       +
       

     

       360
       360
       +
         let mem key = function

     

       361
       361
       +
           | `O pairs -> List.exists (fun (k, _) -> k = key) pairs

     

       362
       362
       +
           | _ -> false

     

       363
       363
       +
       

     

       364
       364
       +
         let find key = function

     

       365
       365
       +
           | `O pairs -> List.assoc_opt key pairs

     

       366
       366
       +
           | _ -> None

     

       367
       367
       +
       

     

       368
       368
       +
         let get key v =

     

       369
       369
       +
           match find key v with

     

       370
       370
       +
           | Some v -> v

     

       371
       371
       +
           | None -> raise Not_found

     

       372
       372
       +
       

     

       373
       373
       +
         let keys v = match v with

     

       374
       374
       +
           | `O pairs -> List.map fst pairs

     

       375
       375
       +
           | _ -> type_error "object" v

     

       376
       376
       +
       

     

       377
       377
       +
         let values v = match v with

     

       378
       378
       +
           | `O pairs -> List.map snd pairs

     

       379
       379
       +
           | _ -> type_error "object" v

     

       380
       380
       +
       

     

       381
       381
       +
         let update key value = function

     

       382
       382
       +
           | `O pairs ->

     

       383
       383
       +
               let rec go = function

     

       384
       384
       +
                 | [] -> [(key, value)]

     

       385
       385
       +
                 | (k, _) :: rest when k = key -> (key, value) :: rest

     

       386
       386
       +
                 | kv :: rest -> kv :: go rest

     

       387
       387
       +
               in

     

       388
       388
       +
               `O (go pairs)

     

       389
       389
       +
           | v -> type_error "object" v

     

       390
       390
       +
       

     

       391
       391
       +
         let remove key = function

     

       392
       392
       +
           | `O pairs -> `O (List.filter (fun (k, _) -> k <> key) pairs)

     

       393
       393
       +
           | v -> type_error "object" v

     

       394
       394
       +
       

     

       395
       395
       +
         let combine v1 v2 =

     

       396
       396
       +
           match v1, v2 with

     

       397
       397
       +
           | `O o1, `O o2 -> `O (o1 @ o2)

     

       398
       398
       +
           | `O _, _ -> type_error "object" v2

     

       399
       399
       +
           | _, _ -> type_error "object" v1

     

       400
       400
       +
       

     

       401
       401
       +
         (** {3 List Operations} *)

     

       402
       402
       +
       

     

       403
       403
       +
         let map f = function

     

       404
       404
       +
           | `A l -> `A (List.map f l)

     

       405
       405
       +
           | v -> type_error "list" v

     

       406
       406
       +
       

     

       407
       407
       +
         let mapi f = function

     

       408
       408
       +
           | `A l -> `A (List.mapi f l)

     

       409
       409
       +
           | v -> type_error "list" v

     

       410
       410
       +
       

     

       411
       411
       +
         let filter pred = function

     

       412
       412
       +
           | `A l -> `A (List.filter pred l)

     

       413
       413
       +
           | v -> type_error "list" v

     

       414
       414
       +
       

     

       415
       415
       +
         let fold f init = function

     

       416
       416
       +
           | `A l -> List.fold_left f init l

     

       417
       417
       +
           | v -> type_error "list" v

     

       418
       418
       +
       

     

       419
       419
       +
         let nth n = function

     

       420
       420
       +
           | `A l -> List.nth_opt l n

     

       421
       421
       +
           | _ -> None

     

       422
       422
       +
       

     

       423
       423
       +
         let length = function

     

       424
       424
       +
           | `A l -> List.length l

     

       425
       425
       +
           | `O o -> List.length o

     

       426
       426
       +
           | _ -> 0

     

       427
       427
       +
       

     

       428
       428
       +
         let flatten = function

     

       429
       429
       +
           | `A l ->

     

       430
       430
       +
               `A (List.concat_map (function `A inner -> inner | v -> [v]) l)

     

       431
       431
       +
           | v -> type_error "list" v

     

       432
       432
       +
       

     

       433
       433
       +
         (** {3 Path Operations} *)

     

       434
       434
       +
       

     

       435
       435
       +
         let rec get_path path v =

     

       436
       436
       +
           match path with

     

       437
       437
       +
           | [] -> Some v

     

       438
       438
       +
           | key :: rest ->

     

       439
       439
       +
               match find key v with

     

       440
       440
       +
               | Some child -> get_path rest child

     

       441
       441
       +
               | None -> None

     

       442
       442
       +
       

     

       443
       443
       +
         let get_path_exn path v =

     

       444
       444
       +
           match get_path path v with

     

       445
       445
       +
           | Some v -> v

     

       446
       446
       +
           | None -> raise Not_found

     

       447
       447
       +
       

     

       448
       448
       +
         (** {3 Iteration} *)

     

       449
       449
       +
       

     

       450
       450
       +
         let iter_obj f = function

     

       451
       451
       +
           | `O pairs -> List.iter (fun (k, v) -> f k v) pairs

     

       452
       452
       +
           | v -> type_error "object" v

     

       453
       453
       +
       

     

       454
       454
       +
         let iter_list f = function

     

       455
       455
       +
           | `A l -> List.iter f l

     

       456
       456
       +
           | v -> type_error "list" v

     

       457
       457
       +
       

     

       458
       458
       +
         let fold_obj f init = function

     

       459
       459
       +
           | `O pairs -> List.fold_left (fun acc (k, v) -> f acc k v) init pairs

     

       460
       460
       +
           | v -> type_error "object" v

     

       461
       461
       +
       

     

       462
       462
       +
         (** {3 Mapping} *)

     

       463
       463
       +
       

     

       464
       464
       +
         let map_obj f = function

     

       465
       465
       +
           | `O pairs -> `O (List.map (fun (k, v) -> (k, f k v)) pairs)

     

       466
       466
       +
           | v -> type_error "object" v

     

       467
       467
       +
       

     

       468
       468
       +
         let filter_obj pred = function

     

       469
       469
       +
           | `O pairs -> `O (List.filter (fun (k, v) -> pred k v) pairs)

     

       470
       470
       +
           | v -> type_error "object" v

     

       471
       471
       +
       

     

       472
       472
       +
         (** {3 Conversion Helpers} *)

     

       473
       473
       +
       

     

       474
       474
       +
         let to_bool ?default v =

     

       475
       475
       +
           match as_bool v, default with

     

       476
       476
       +
           | Some b, _ -> b

     

       477
       477
       +
           | None, Some d -> d

     

       478
       478
       +
           | None, None -> type_error "bool" v

     

       479
       479
       +
       

     

       480
       480
       +
         let to_int ?default v =

     

       481
       481
       +
           match as_int v, default with

     

       482
       482
       +
           | Some i, _ -> i

     

       483
       483
       +
           | None, Some d -> d

     

       484
       484
       +
           | None, None -> type_error "int" v

     

       485
       485
       +
       

     

       486
       486
       +
         let to_float ?default v =

     

       487
       487
       +
           match as_float v, default with

     

       488
       488
       +
           | Some f, _ -> f

     

       489
       489
       +
           | None, Some d -> d

     

       490
       490
       +
           | None, None -> type_error "float" v

     

       491
       491
       +
       

     

       492
       492
       +
         let to_string ?default v =

     

       493
       493
       +
           match as_string v, default with

     

       494
       494
       +
           | Some s, _ -> s

     

       495
       495
       +
           | None, Some d -> d

     

       496
       496
       +
           | None, None -> type_error "string" v

     

       497
       497
       +
       

     

       498
       498
       +
         let to_list ?default v =

     

       499
       499
       +
           match as_list v, default with

     

       500
       500
       +
           | Some l, _ -> l

     

       501
       501
       +
           | None, Some d -> d

     

       502
       502
       +
           | None, None -> type_error "list" v

     

       503
       503
       +
       end

     

       504
       504
       +
       

     

       505
       505
       +
       

     

       506
       506
       +
       (** {2 Stream - Low-Level Event API} *)

     

       507
       507
       +
       

     

       508
       508
       +
       module Stream = struct

     

       509
       509
       +
         (** Low-level streaming API for event-based YAML processing.

     

       510
       510
       +
       

     

       511
       511
       +
             This is useful for:

     

       512
       512
       +
             - Processing very large YAML files incrementally

     

       513
       513
       +
             - Building custom YAML transformers

     

       514
       514
       +
             - Fine-grained control over YAML emission *)

     

       515
       515
       +
       

     

       516
       516
       +
         (** {3 Event Types} *)

     

       517
       517
       +
       

     

       518
       518
       +
         type event = Event.t

     

       519
       519
       +
         (** A parsing or emitting event. *)

     

       520
       520
       +
       

     

       521
       521
       +
         type position = Position.t

     

       522
       522
       +
         (** A position in the source (line, column, byte offset). *)

     

       523
       523
       +
       

     

       524
       524
       +
         (** Result of parsing an event. *)

     

       525
       525
       +
         type event_result = {

     

       526
       526
       +
           event : event;

     

       527
       527
       +
           start_pos : position;

     

       528
       528
       +
           end_pos : position;

     

       529
       529
       +
         }

     

       530
       530
       +
       

     

       531
       531
       +
         (** {3 Parsing} *)

     

       532
       532
       +
       

     

       533
       533
       +
         type parser = Parser.t

     

       534
       534
       +
         (** A streaming YAML parser. *)

     

       535
       535
       +
       

     

       536
       536
       +
         let parser s = Parser.of_string s

     

       537
       537
       +
         (** Create a parser from a string. *)

     

       538
       538
       +
       

     

       539
       539
       +
         let next p =

     

       540
       540
       +
           match Parser.next p with

     

       541
       541
       +
           | Some { event; span } ->

     

       542
       542
       +
               Some {

     

       543
       543
       +
                 event;

     

       544
       544
       +
                 start_pos = span.start;

     

       545
       545
       +
                 end_pos = span.stop;

     

       546
       546
       +
               }

     

       547
       547
       +
           | None -> None

     

       548
       548
       +
         (** Get the next event from the parser.

     

       549
       549
       +
             Returns [None] when parsing is complete. *)

     

       550
       550
       +
       

     

       551
       551
       +
         let iter f p =

     

       552
       552
       +
           let rec go () =

     

       553
       553
       +
             match next p with

     

       554
       554
       +
             | Some { event; start_pos; end_pos } ->

     

       555
       555
       +
                 f event start_pos end_pos;

     

       556
       556
       +
                 go ()

     

       557
       557
       +
             | None -> ()

     

       558
       558
       +
           in

     

       559
       559
       +
           go ()

     

       560
       560
       +
         (** Iterate over all events from the parser. *)

     

       561
       561
       +
       

     

       562
       562
       +
         let fold f init p =

     

       563
       563
       +
           let rec go acc =

     

       564
       564
       +
             match Parser.next p with

     

       565
       565
       +
             | Some { event; _ } -> go (f acc event)

     

       566
       566
       +
             | None -> acc

     

       567
       567
       +
           in

     

       568
       568
       +
           go init

     

       569
       569
       +
         (** Fold over all events from the parser. *)

     

       570
       570
       +
       

     

       571
       571
       +
         (** {3 Emitting} *)

     

       572
       572
       +
       

     

       573
       573
       +
         type emitter = Emitter.t

     

       574
       574
       +
         (** A streaming YAML emitter. *)

     

       575
       575
       +
       

     

       576
       576
       +
         let emitter ?len:_ () = Emitter.create ()

     

       577
       577
       +
         (** Create a new emitter. *)

     

       578
       578
       +
       

     

       579
       579
       +
         let contents e = Emitter.contents e

     

       580
       580
       +
         (** Get the emitted YAML string. *)

     

       581
       581
       +
       

     

       582
       582
       +
         let emit e ev = Emitter.emit e ev

     

       583
       583
       +
         (** Emit an event. *)

     

       584
       584
       +
       

     

       585
       585
       +
         (** {3 Event Emission Helpers} *)

     

       586
       586
       +
       

     

       587
       587
       +
         let stream_start e enc =

     

       588
       588
       +
           Emitter.emit e (Event.Stream_start { encoding = enc })

     

       589
       589
       +
       

     

       590
       590
       +
         let stream_end e =

     

       591
       591
       +
           Emitter.emit e Event.Stream_end

     

       592
       592
       +
       

     

       593
       593
       +
         let document_start e ?version ?(implicit = true) () =

     

       594
       594
       +
           let version = match version with

     

       595
       595
       +
             | Some `V1_1 -> Some (1, 1)

     

       596
       596
       +
             | Some `V1_2 -> Some (1, 2)

     

       597
       597
       +
             | None -> None

     

       598
       598
       +
           in

     

       599
       599
       +
           Emitter.emit e (Event.Document_start { version; implicit })

     

       600
       600
       +
       

     

       601
       601
       +
         let document_end e ?(implicit = true) () =

     

       602
       602
       +
           Emitter.emit e (Event.Document_end { implicit })

     

       603
       603
       +
       

     

       604
       604
       +
         let scalar e ?anchor ?tag ?(style = `Any) value =

     

       605
       605
       +
           Emitter.emit e (Event.Scalar {

     

       606
       606
       +
             anchor;

     

       607
       607
       +
             tag;

     

       608
       608
       +
             value;

     

       609
       609
       +
             plain_implicit = true;

     

       610
       610
       +
             quoted_implicit = true;

     

       611
       611
       +
             style;

     

       612
       612
       +
           })

     

       613
       613
       +
       

     

       614
       614
       +
         let alias e name =

     

       615
       615
       +
           Emitter.emit e (Event.Alias { anchor = name })

     

       616
       616
       +
       

     

       617
       617
       +
         let sequence_start e ?anchor ?tag ?(style = `Any) () =

     

       618
       618
       +
           Emitter.emit e (Event.Sequence_start {

     

       619
       619
       +
             anchor;

     

       620
       620
       +
             tag;

     

       621
       621
       +
             implicit = true;

     

       622
       622
       +
             style;

     

       623
       623
       +
           })

     

       624
       624
       +
       

     

       625
       625
       +
         let sequence_end e =

     

       626
       626
       +
           Emitter.emit e Event.Sequence_end

     

       627
       627
       +
       

     

       628
       628
       +
         let mapping_start e ?anchor ?tag ?(style = `Any) () =

     

       629
       629
       +
           Emitter.emit e (Event.Mapping_start {

     

       630
       630
       +
             anchor;

     

       631
       631
       +
             tag;

     

       632
       632
       +
             implicit = true;

     

       633
       633
       +
             style;

     

       634
       634
       +
           })

     

       635
       635
       +
       

     

       636
       636
       +
         let mapping_end e =

     

       637
       637
       +
           Emitter.emit e Event.Mapping_end

     

       638
       638
       +
       end

     

       639
       639
       +
       

     

       640
       640
       +
       

     

       641
       641
       +
       (** {2 Internal Modules} *)

     

       642
       642
       +
       

     

       643
       643
       +
       (** These modules are exposed for advanced use cases requiring

     

       644
       644
       +
           fine-grained control over parsing, emission, or data structures.

     

       645
       645
       +
       

     

       646
       646
       +
           For typical usage, prefer the top-level functions and {!Util}. *)

     

       647
       647
       +
       

     

       648
       648
       +
       (** Source position tracking. *)

     

       649
       649
       +
       module Position = Position

     

       650
       650
       +
       

     

       651
       651
       +
       (** Source span (range of positions). *)

     

       652
       652
       +
       module Span = Span

     

       653
       653
       +
       

     

       654
       654
       +
       (** Block scalar chomping modes. *)

     

       655
       655
       +
       module Chomping = Chomping

     

       656
       656
       +
       

     

       657
       657
       +
       (** YAML type tags. *)

     

       658
       658
       +
       module Tag = Tag

     

       659
       659
       +
       

     

       660
       660
       +
       (** JSON-compatible value type and operations. *)

     

       661
       661
       +
       module Value = Value

     

       662
       662
       +
       

     

       663
       663
       +
       (** YAML scalar with metadata. *)

     

       664
       664
       +
       module Scalar = Scalar

     

       665
       665
       +
       

     

       666
       666
       +
       (** YAML sequence with metadata. *)

     

       667
       667
       +
       module Sequence = Sequence

     

       668
       668
       +
       

     

       669
       669
       +
       (** YAML mapping with metadata. *)

     

       670
       670
       +
       module Mapping = Mapping

     

       671
       671
       +
       

     

       672
       672
       +
       (** Full YAML value type. *)

     

       673
       673
       +
       module Yaml = Yaml

     

       674
       674
       +
       

     

       675
       675
       +
       (** YAML document with directives. *)

     

       676
       676
       +
       module Document = Document

     

       677
       677
       +
       

     

       678
       678
       +
       (** Lexical tokens. *)

     

       679
       679
       +
       module Token = Token

     

       680
       680
       +
       

     

       681
       681
       +
       (** Lexical scanner. *)

     

       682
       682
       +
       module Scanner = Scanner

     

       683
       683
       +
       

     

       684
       684
       +
       (** Parser events. *)

     

       685
       685
       +
       module Event = Event

     

       686
       686
       +
       

     

       687
       687
       +
       (** Event-based parser. *)

     

       688
       688
       +
       module Parser = Parser

     

       689
       689
       +
       

     

       690
       690
       +
       (** Document loader. *)

     

       691
       691
       +
       module Loader = Loader

     

       692
       692
       +
       

     

       693
       693
       +
       (** Event-based emitter. *)

     

       694
       694
       +
       module Emitter = Emitter

     

       695
       695
       +
       

     

       696
       696
       +
       (** Input stream utilities. *)

     

       697
       697
       +
       module Input = Input

     

       698
       698
       +
       

     

       699
       699
       +
       (** Buffer serialization utilities. *)

     

       700
       700
       +
       module Serialize = Serialize

+689

lib/yamlrw.mli

···

       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
       +
       (** {1 Yamlrw - A Pure OCaml YAML Parser and Emitter}

     

       7
       7
       +
       

     

       8
       8
       +
           Yamlrw is a pure OCaml implementation of YAML 1.1/1.2 parsing and emission.

     

       9
       9
       +
           It provides both a high-level JSON-compatible interface and a lower-level

     

       10
       10
       +
           streaming API for fine-grained control.

     

       11
       11
       +
       

     

       12
       12
       +
           {2 Quick Start}

     

       13
       13
       +
       

     

       14
       14
       +
           Parse a YAML string:

     

       15
       15
       +
           {[

     

       16
       16
       +
             let value = Yamlrw.of_string "name: Alice\nage: 30" in

     

       17
       17
       +
             match value with

     

       18
       18
       +
             | `O [("name", `String "Alice"); ("age", `Float 30.)] -> ...

     

       19
       19
       +
             | _ -> ...

     

       20
       20
       +
           ]}

     

       21
       21
       +
       

     

       22
       22
       +
           Serialize to YAML:

     

       23
       23
       +
           {[

     

       24
       24
       +
             let yaml = `O [("name", `String "Bob"); ("active", `Bool true)] in

     

       25
       25
       +
             let s = Yamlrw.to_string yaml in

     

       26
       26
       +
             (* "name: Bob\nactive: true\n" *)

     

       27
       27
       +
           ]}

     

       28
       28
       +
       

     

       29
       29
       +
           Use the Util module for convenient access:

     

       30
       30
       +
           {[

     

       31
       31
       +
             let name = Yamlrw.Util.(get_string (get "name" value)) in

     

       32
       32
       +
             let age = Yamlrw.Util.(get_int (get "age" value)) in

     

       33
       33
       +
           ]} *)

     

       34
       34
       +
       

     

       35
       35
       +
       

     

       36
       36
       +
       (** {2 Error Handling} *)

     

       37
       37
       +
       

     

       38
       38
       +
       module Error = Error

     

       39
       39
       +
       

     

       40
       40
       +
       exception Yamlrw_error of Error.t

     

       41
       41
       +
       (** Raised on parse or emit errors. *)

     

       42
       42
       +
       

     

       43
       43
       +
       

     

       44
       44
       +
       (** {2 Core Types} *)

     

       45
       45
       +
       

     

       46
       46
       +
       type value = [

     

       47
       47
       +
         | `Null                      (** YAML null, ~, or empty values *)

     

       48
       48
       +
         | `Bool of bool              (** YAML booleans (true, false, yes, no, on, off) *)

     

       49
       49
       +
         | `Float of float            (** All YAML numbers (integers stored as floats) *)

     

       50
       50
       +
         | `String of string          (** YAML strings *)

     

       51
       51
       +
         | `A of value list           (** YAML sequences/arrays *)

     

       52
       52
       +
         | `O of (string * value) list (** YAML mappings/objects with string keys *)

     

       53
       53
       +
       ]

     

       54
       54
       +
       (** JSON-compatible YAML representation. Use this for simple data interchange.

     

       55
       55
       +
       

     

       56
       56
       +
           This type is structurally equivalent to {!Value.t} and compatible with the

     

       57
       57
       +
           ezjsonm representation. For additional operations, see {!Value} and {!Util}. *)

     

       58
       58
       +
       

     

       59
       59
       +
       type yaml = [

     

       60
       60
       +
         | `Scalar of Scalar.t      (** YAML scalar value with style and metadata *)

     

       61
       61
       +
         | `Alias of string         (** Alias reference to an anchored node *)

     

       62
       62
       +
         | `A of yaml Sequence.t    (** YAML sequence with style and metadata *)

     

       63
       63
       +
         | `O of (yaml, yaml) Mapping.t (** YAML mapping with style and metadata *)

     

       64
       64
       +
       ]

     

       65
       65
       +
       (** Full YAML representation preserving anchors, tags, and aliases.

     

       66
       66
       +
       

     

       67
       67
       +
           This type is structurally equivalent to {!Yaml.t}. Use this when you need

     

       68
       68
       +
           access to YAML-specific features like anchors and aliases for node reuse,

     

       69
       69
       +
           type tags for custom types, scalar styles (plain, quoted, literal, folded),

     

       70
       70
       +
           and collection styles (block vs flow).

     

       71
       71
       +
       

     

       72
       72
       +
           For additional operations, see {!Yaml}, {!Scalar}, {!Sequence}, and {!Mapping}. *)

     

       73
       73
       +
       

     

       74
       74
       +
       type document = {

     

       75
       75
       +
         version : (int * int) option;        (** Optional YAML version directive (e.g., (1, 2) for YAML 1.2) *)

     

       76
       76
       +
         tags : (string * string) list;       (** TAG directives mapping handles to prefixes *)

     

       77
       77
       +
         root : yaml option;                  (** Root content of the document *)

     

       78
       78
       +
         implicit_start : bool;               (** Whether the document start marker (---) is implicit *)

     

       79
       79
       +
         implicit_end : bool;                 (** Whether the document end marker (...) is implicit *)

     

       80
       80
       +
       }

     

       81
       81
       +
       (** A YAML document with directives and metadata.

     

       82
       82
       +
       

     

       83
       83
       +
           This type is structurally equivalent to {!Document.t}. A YAML stream can

     

       84
       84
       +
           contain multiple documents, each separated by document markers.

     

       85
       85
       +
       

     

       86
       86
       +
           For additional operations, see {!Document}. *)

     

       87
       87
       +
       

     

       88
       88
       +
       

     

       89
       89
       +
       (** {2 Character Encoding} *)

     

       90
       90
       +
       

     

       91
       91
       +
       module Encoding = Encoding

     

       92
       92
       +
       

     

       93
       93
       +
       

     

       94
       94
       +
       (** {2 Parsing} *)

     

       95
       95
       +
       

     

       96
       96
       +
       type version = [ `V1_1 | `V1_2 ]

     

       97
       97
       +
       (** YAML specification version. *)

     

       98
       98
       +
       

     

       99
       99
       +
       val default_max_alias_nodes : int

     

       100
       100
       +
       (** Default maximum nodes during alias expansion (10 million). *)

     

       101
       101
       +
       

     

       102
       102
       +
       val default_max_alias_depth : int

     

       103
       103
       +
       (** Default maximum alias nesting depth (100). *)

     

       104
       104
       +
       

     

       105
       105
       +
       val of_string :

     

       106
       106
       +
         ?resolve_aliases:bool ->

     

       107
       107
       +
         ?max_nodes:int ->

     

       108
       108
       +
         ?max_depth:int ->

     

       109
       109
       +
         string -> value

     

       110
       110
       +
       (** Parse a YAML string into a JSON-compatible value.

     

       111
       111
       +
       

     

       112
       112
       +
           @param resolve_aliases Whether to expand aliases (default: true)

     

       113
       113
       +
           @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       114
       114
       +
           @param max_depth Maximum alias nesting depth (default: 100)

     

       115
       115
       +
           @raise Yamlrw_error on parse error or if multiple documents found *)

     

       116
       116
       +
       

     

       117
       117
       +
       val yaml_of_string :

     

       118
       118
       +
         ?resolve_aliases:bool ->

     

       119
       119
       +
         ?max_nodes:int ->

     

       120
       120
       +
         ?max_depth:int ->

     

       121
       121
       +
         string -> yaml

     

       122
       122
       +
       (** Parse a YAML string preserving full YAML metadata (anchors, tags, etc).

     

       123
       123
       +
       

     

       124
       124
       +
           By default, aliases are NOT resolved, preserving the document structure.

     

       125
       125
       +
       

     

       126
       126
       +
           @param resolve_aliases Whether to expand aliases (default: false)

     

       127
       127
       +
           @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       128
       128
       +
           @param max_depth Maximum alias nesting depth (default: 100)

     

       129
       129
       +
           @raise Yamlrw_error on parse error or if multiple documents found *)

     

       130
       130
       +
       

     

       131
       131
       +
       val documents_of_string : string -> document list

     

       132
       132
       +
       (** Parse a multi-document YAML stream.

     

       133
       133
       +
       

     

       134
       134
       +
           Use this when your YAML input contains multiple documents separated

     

       135
       135
       +
           by document markers (---).

     

       136
       136
       +
       

     

       137
       137
       +
           @raise Yamlrw_error on parse error *)

     

       138
       138
       +
       

     

       139
       139
       +
       

     

       140
       140
       +
       (** {2 Formatting Styles} *)

     

       141
       141
       +
       

     

       142
       142
       +
       module Scalar_style = Scalar_style

     

       143
       143
       +
       

     

       144
       144
       +
       module Layout_style = Layout_style

     

       145
       145
       +
       

     

       146
       146
       +
       

     

       147
       147
       +
       (** {2 Serialization} *)

     

       148
       148
       +
       

     

       149
       149
       +
       val to_buffer :

     

       150
       150
       +
         ?encoding:Encoding.t ->

     

       151
       151
       +
         ?scalar_style:Scalar_style.t ->

     

       152
       152
       +
         ?layout_style:Layout_style.t ->

     

       153
       153
       +
         ?buffer:Buffer.t ->

     

       154
       154
       +
         value -> Buffer.t

     

       155
       155
       +
       (** Serialize a value to a buffer.

     

       156
       156
       +
       

     

       157
       157
       +
           @param encoding Output encoding (default: UTF-8)

     

       158
       158
       +
           @param scalar_style Preferred scalar style (default: Any)

     

       159
       159
       +
           @param layout_style Preferred layout style (default: Any)

     

       160
       160
       +
           @param buffer Optional buffer to append to (allocates new one if not provided)

     

       161
       161
       +
           @return The buffer containing the serialized YAML *)

     

       162
       162
       +
       

     

       163
       163
       +
       val to_string :

     

       164
       164
       +
         ?encoding:Encoding.t ->

     

       165
       165
       +
         ?scalar_style:Scalar_style.t ->

     

       166
       166
       +
         ?layout_style:Layout_style.t ->

     

       167
       167
       +
         value -> string

     

       168
       168
       +
       (** Serialize a value to a YAML string.

     

       169
       169
       +
       

     

       170
       170
       +
           @param encoding Output encoding (default: UTF-8)

     

       171
       171
       +
           @param scalar_style Preferred scalar style (default: Any)

     

       172
       172
       +
           @param layout_style Preferred layout style (default: Any) *)

     

       173
       173
       +
       

     

       174
       174
       +
       val yaml_to_buffer :

     

       175
       175
       +
         ?encoding:Encoding.t ->

     

       176
       176
       +
         ?scalar_style:Scalar_style.t ->

     

       177
       177
       +
         ?layout_style:Layout_style.t ->

     

       178
       178
       +
         ?buffer:Buffer.t ->

     

       179
       179
       +
         yaml -> Buffer.t

     

       180
       180
       +
       (** Serialize a full YAML value to a buffer.

     

       181
       181
       +
       

     

       182
       182
       +
           @param encoding Output encoding (default: UTF-8)

     

       183
       183
       +
           @param scalar_style Preferred scalar style (default: Any)

     

       184
       184
       +
           @param layout_style Preferred layout style (default: Any)

     

       185
       185
       +
           @param buffer Optional buffer to append to (allocates new one if not provided)

     

       186
       186
       +
           @return The buffer containing the serialized YAML *)

     

       187
       187
       +
       

     

       188
       188
       +
       val yaml_to_string :

     

       189
       189
       +
         ?encoding:Encoding.t ->

     

       190
       190
       +
         ?scalar_style:Scalar_style.t ->

     

       191
       191
       +
         ?layout_style:Layout_style.t ->

     

       192
       192
       +
         yaml -> string

     

       193
       193
       +
       (** Serialize a full YAML value to a string.

     

       194
       194
       +
       

     

       195
       195
       +
           @param encoding Output encoding (default: UTF-8)

     

       196
       196
       +
           @param scalar_style Preferred scalar style (default: Any)

     

       197
       197
       +
           @param layout_style Preferred layout style (default: Any) *)

     

       198
       198
       +
       

     

       199
       199
       +
       val documents_to_buffer :

     

       200
       200
       +
         ?encoding:Encoding.t ->

     

       201
       201
       +
         ?scalar_style:Scalar_style.t ->

     

       202
       202
       +
         ?layout_style:Layout_style.t ->

     

       203
       203
       +
         ?resolve_aliases:bool ->

     

       204
       204
       +
         ?buffer:Buffer.t ->

     

       205
       205
       +
         document list -> Buffer.t

     

       206
       206
       +
       (** Serialize multiple documents to a buffer.

     

       207
       207
       +
       

     

       208
       208
       +
           @param encoding Output encoding (default: UTF-8)

     

       209
       209
       +
           @param scalar_style Preferred scalar style (default: Any)

     

       210
       210
       +
           @param layout_style Preferred layout style (default: Any)

     

       211
       211
       +
           @param resolve_aliases Whether to expand aliases (default: true)

     

       212
       212
       +
           @param buffer Optional buffer to append to (allocates new one if not provided)

     

       213
       213
       +
           @return The buffer containing the serialized YAML *)

     

       214
       214
       +
       

     

       215
       215
       +
       val documents_to_string :

     

       216
       216
       +
         ?encoding:Encoding.t ->

     

       217
       217
       +
         ?scalar_style:Scalar_style.t ->

     

       218
       218
       +
         ?layout_style:Layout_style.t ->

     

       219
       219
       +
         ?resolve_aliases:bool ->

     

       220
       220
       +
         document list -> string

     

       221
       221
       +
       (** Serialize multiple documents to a YAML stream.

     

       222
       222
       +
       

     

       223
       223
       +
           @param encoding Output encoding (default: UTF-8)

     

       224
       224
       +
           @param scalar_style Preferred scalar style (default: Any)

     

       225
       225
       +
           @param layout_style Preferred layout style (default: Any)

     

       226
       226
       +
           @param resolve_aliases Whether to expand aliases (default: true) *)

     

       227
       227
       +
       

     

       228
       228
       +
       (** {2 Buffer Parsing} *)

     

       229
       229
       +
       

     

       230
       230
       +
       val of_buffer :

     

       231
       231
       +
         ?resolve_aliases:bool ->

     

       232
       232
       +
         ?max_nodes:int ->

     

       233
       233
       +
         ?max_depth:int ->

     

       234
       234
       +
         Buffer.t -> value

     

       235
       235
       +
       (** Parse YAML from a buffer into a JSON-compatible value.

     

       236
       236
       +
       

     

       237
       237
       +
           @param resolve_aliases Whether to expand aliases (default: true)

     

       238
       238
       +
           @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       239
       239
       +
           @param max_depth Maximum alias nesting depth (default: 100)

     

       240
       240
       +
           @raise Yamlrw_error on parse error or if multiple documents found *)

     

       241
       241
       +
       

     

       242
       242
       +
       val yaml_of_buffer :

     

       243
       243
       +
         ?resolve_aliases:bool ->

     

       244
       244
       +
         ?max_nodes:int ->

     

       245
       245
       +
         ?max_depth:int ->

     

       246
       246
       +
         Buffer.t -> yaml

     

       247
       247
       +
       (** Parse YAML from a buffer preserving full YAML metadata.

     

       248
       248
       +
       

     

       249
       249
       +
           @param resolve_aliases Whether to expand aliases (default: false)

     

       250
       250
       +
           @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       251
       251
       +
           @param max_depth Maximum alias nesting depth (default: 100)

     

       252
       252
       +
           @raise Yamlrw_error on parse error or if multiple documents found *)

     

       253
       253
       +
       

     

       254
       254
       +
       val documents_of_buffer : Buffer.t -> document list

     

       255
       255
       +
       (** Parse a multi-document YAML stream from a buffer.

     

       256
       256
       +
       

     

       257
       257
       +
           @raise Yamlrw_error on parse error *)

     

       258
       258
       +
       

     

       259
       259
       +
       

     

       260
       260
       +
       (** {2 Conversion} *)

     

       261
       261
       +
       

     

       262
       262
       +
       val to_json :

     

       263
       263
       +
         ?resolve_aliases:bool ->

     

       264
       264
       +
         ?max_nodes:int ->

     

       265
       265
       +
         ?max_depth:int ->

     

       266
       266
       +
         yaml -> value

     

       267
       267
       +
       (** Convert full YAML to JSON-compatible value.

     

       268
       268
       +
       

     

       269
       269
       +
           @param resolve_aliases Whether to expand aliases (default: true)

     

       270
       270
       +
           @param max_nodes Maximum nodes during alias expansion (default: 10M)

     

       271
       271
       +
           @param max_depth Maximum alias nesting depth (default: 100)

     

       272
       272
       +
           @raise Yamlrw_error if alias limits exceeded or complex keys found *)

     

       273
       273
       +
       

     

       274
       274
       +
       val of_json : value -> yaml

     

       275
       275
       +
       (** Convert JSON-compatible value to full YAML representation. *)

     

       276
       276
       +
       

     

       277
       277
       +
       

     

       278
       278
       +
       (** {2 Pretty Printing & Equality} *)

     

       279
       279
       +
       

     

       280
       280
       +
       val pp : Format.formatter -> value -> unit

     

       281
       281
       +
       (** Pretty-print a value. *)

     

       282
       282
       +
       

     

       283
       283
       +
       val equal : value -> value -> bool

     

       284
       284
       +
       (** Test equality of two values. *)

     

       285
       285
       +
       

     

       286
       286
       +
       

     

       287
       287
       +
       (** {2 Util - Value Combinators}

     

       288
       288
       +
       

     

       289
       289
       +
           Combinators for working with {!type:value} values.

     

       290
       290
       +
       

     

       291
       291
       +
           This module provides constructors, accessors, and transformations

     

       292
       292
       +
           for JSON-compatible YAML values. *)

     

       293
       293
       +
       

     

       294
       294
       +
       module Util : sig

     

       295
       295
       +
         type t = Value.t

     

       296
       296
       +
         (** Alias for {!type:value}. *)

     

       297
       297
       +
       

     

       298
       298
       +
         (** {3 Type Error} *)

     

       299
       299
       +
       

     

       300
       300
       +
         exception Type_error of string * t

     

       301
       301
       +
         (** Raised when a value has unexpected type.

     

       302
       302
       +
             [Type_error (expected, actual_value)] *)

     

       303
       303
       +
       

     

       304
       304
       +
         (** {3 Constructors} *)

     

       305
       305
       +
       

     

       306
       306
       +
         val null : t

     

       307
       307
       +
         (** The null value. *)

     

       308
       308
       +
       

     

       309
       309
       +
         val bool : bool -> t

     

       310
       310
       +
         (** Create a boolean value. *)

     

       311
       311
       +
       

     

       312
       312
       +
         val int : int -> t

     

       313
       313
       +
         (** Create an integer value (stored as float). *)

     

       314
       314
       +
       

     

       315
       315
       +
         val float : float -> t

     

       316
       316
       +
         (** Create a float value. *)

     

       317
       317
       +
       

     

       318
       318
       +
         val string : string -> t

     

       319
       319
       +
         (** Create a string value. *)

     

       320
       320
       +
       

     

       321
       321
       +
         val strings : string list -> t

     

       322
       322
       +
         (** Create a list of strings. *)

     

       323
       323
       +
       

     

       324
       324
       +
         val list : t list -> t

     

       325
       325
       +
         (** Create a list value. *)

     

       326
       326
       +
       

     

       327
       327
       +
         val obj : (string * t) list -> t

     

       328
       328
       +
         (** Create an object value from key-value pairs. *)

     

       329
       329
       +
       

     

       330
       330
       +
         (** {3 Type Predicates} *)

     

       331
       331
       +
       

     

       332
       332
       +
         val is_null : t -> bool

     

       333
       333
       +
         (** Check if value is null. *)

     

       334
       334
       +
       

     

       335
       335
       +
         val is_bool : t -> bool

     

       336
       336
       +
         (** Check if value is a boolean. *)

     

       337
       337
       +
       

     

       338
       338
       +
         val is_number : t -> bool

     

       339
       339
       +
         (** Check if value is a number. *)

     

       340
       340
       +
       

     

       341
       341
       +
         val is_string : t -> bool

     

       342
       342
       +
         (** Check if value is a string. *)

     

       343
       343
       +
       

     

       344
       344
       +
         val is_list : t -> bool

     

       345
       345
       +
         (** Check if value is a list. *)

     

       346
       346
       +
       

     

       347
       347
       +
         val is_obj : t -> bool

     

       348
       348
       +
         (** Check if value is an object. *)

     

       349
       349
       +
       

     

       350
       350
       +
         (** {3 Safe Accessors}

     

       351
       351
       +
       

     

       352
       352
       +
             These return [None] if the value has the wrong type. *)

     

       353
       353
       +
       

     

       354
       354
       +
         val as_null : t -> unit option

     

       355
       355
       +
         (** Get unit if value is null. *)

     

       356
       356
       +
       

     

       357
       357
       +
         val as_bool : t -> bool option

     

       358
       358
       +
         (** Get boolean value. *)

     

       359
       359
       +
       

     

       360
       360
       +
         val as_float : t -> float option

     

       361
       361
       +
         (** Get float value. *)

     

       362
       362
       +
       

     

       363
       363
       +
         val as_string : t -> string option

     

       364
       364
       +
         (** Get string value. *)

     

       365
       365
       +
       

     

       366
       366
       +
         val as_list : t -> t list option

     

       367
       367
       +
         (** Get list value. *)

     

       368
       368
       +
       

     

       369
       369
       +
         val as_obj : t -> (string * t) list option

     

       370
       370
       +
         (** Get object as association list. *)

     

       371
       371
       +
       

     

       372
       372
       +
         val as_int : t -> int option

     

       373
       373
       +
         (** Get integer value if float is an exact integer. *)

     

       374
       374
       +
       

     

       375
       375
       +
         (** {3 Unsafe Accessors}

     

       376
       376
       +
       

     

       377
       377
       +
             These raise {!Type_error} if the value has the wrong type. *)

     

       378
       378
       +
       

     

       379
       379
       +
         val get_null : t -> unit

     

       380
       380
       +
         (** Get unit or raise {!Type_error}. *)

     

       381
       381
       +
       

     

       382
       382
       +
         val get_bool : t -> bool

     

       383
       383
       +
         (** Get boolean or raise {!Type_error}. *)

     

       384
       384
       +
       

     

       385
       385
       +
         val get_float : t -> float

     

       386
       386
       +
         (** Get float or raise {!Type_error}. *)

     

       387
       387
       +
       

     

       388
       388
       +
         val get_string : t -> string

     

       389
       389
       +
         (** Get string or raise {!Type_error}. *)

     

       390
       390
       +
       

     

       391
       391
       +
         val get_list : t -> t list

     

       392
       392
       +
         (** Get list or raise {!Type_error}. *)

     

       393
       393
       +
       

     

       394
       394
       +
         val get_obj : t -> (string * t) list

     

       395
       395
       +
         (** Get object or raise {!Type_error}. *)

     

       396
       396
       +
       

     

       397
       397
       +
         val get_int : t -> int

     

       398
       398
       +
         (** Get integer or raise {!Type_error}. *)

     

       399
       399
       +
       

     

       400
       400
       +
         (** {3 Object Operations} *)

     

       401
       401
       +
       

     

       402
       402
       +
         val mem : string -> t -> bool

     

       403
       403
       +
         (** [mem key obj] checks if [key] exists in object [obj].

     

       404
       404
       +
             Returns [false] if [obj] is not an object. *)

     

       405
       405
       +
       

     

       406
       406
       +
         val find : string -> t -> t option

     

       407
       407
       +
         (** [find key obj] looks up [key] in object [obj].

     

       408
       408
       +
             Returns [None] if key not found or if [obj] is not an object. *)

     

       409
       409
       +
       

     

       410
       410
       +
         val get : string -> t -> t

     

       411
       411
       +
         (** [get key obj] looks up [key] in object [obj].

     

       412
       412
       +
             Raises [Not_found] if key not found. *)

     

       413
       413
       +
       

     

       414
       414
       +
         val keys : t -> string list

     

       415
       415
       +
         (** Get all keys from an object.

     

       416
       416
       +
             @raise Type_error if not an object *)

     

       417
       417
       +
       

     

       418
       418
       +
         val values : t -> t list

     

       419
       419
       +
         (** Get all values from an object.

     

       420
       420
       +
             @raise Type_error if not an object *)

     

       421
       421
       +
       

     

       422
       422
       +
         val update : string -> t -> t -> t

     

       423
       423
       +
         (** [update key value obj] sets [key] to [value] in [obj].

     

       424
       424
       +
             Adds the key if it doesn't exist.

     

       425
       425
       +
             @raise Type_error if [obj] is not an object *)

     

       426
       426
       +
       

     

       427
       427
       +
         val remove : string -> t -> t

     

       428
       428
       +
         (** [remove key obj] removes [key] from [obj].

     

       429
       429
       +
             @raise Type_error if [obj] is not an object *)

     

       430
       430
       +
       

     

       431
       431
       +
         val combine : t -> t -> t

     

       432
       432
       +
         (** [combine obj1 obj2] merges two objects, with [obj2] values taking precedence.

     

       433
       433
       +
             @raise Type_error if either argument is not an object *)

     

       434
       434
       +
       

     

       435
       435
       +
         (** {3 List Operations} *)

     

       436
       436
       +
       

     

       437
       437
       +
         val map : (t -> t) -> t -> t

     

       438
       438
       +
         (** [map f lst] applies [f] to each element of list [lst].

     

       439
       439
       +
             @raise Type_error if [lst] is not a list *)

     

       440
       440
       +
       

     

       441
       441
       +
         val mapi : (int -> t -> t) -> t -> t

     

       442
       442
       +
         (** [mapi f lst] applies [f i x] to each element [x] at index [i].

     

       443
       443
       +
             @raise Type_error if [lst] is not a list *)

     

       444
       444
       +
       

     

       445
       445
       +
         val filter : (t -> bool) -> t -> t

     

       446
       446
       +
         (** [filter pred lst] keeps elements satisfying [pred].

     

       447
       447
       +
             @raise Type_error if [lst] is not a list *)

     

       448
       448
       +
       

     

       449
       449
       +
         val fold : ('a -> t -> 'a) -> 'a -> t -> 'a

     

       450
       450
       +
         (** [fold f init lst] folds [f] over list [lst].

     

       451
       451
       +
             @raise Type_error if [lst] is not a list *)

     

       452
       452
       +
       

     

       453
       453
       +
         val nth : int -> t -> t option

     

       454
       454
       +
         (** [nth n lst] gets element at index [n].

     

       455
       455
       +
             Returns [None] if [lst] is not a list or index out of bounds. *)

     

       456
       456
       +
       

     

       457
       457
       +
         val length : t -> int

     

       458
       458
       +
         (** Get the length of a list or object. Returns 0 for other types. *)

     

       459
       459
       +
       

     

       460
       460
       +
         val flatten : t -> t

     

       461
       461
       +
         (** Flatten a list of lists into a single list.

     

       462
       462
       +
             Non-list elements are kept as-is.

     

       463
       463
       +
             @raise Type_error if not a list *)

     

       464
       464
       +
       

     

       465
       465
       +
         (** {3 Path Operations} *)

     

       466
       466
       +
       

     

       467
       467
       +
         val get_path : string list -> t -> t option

     

       468
       468
       +
         (** [get_path ["a"; "b"; "c"] obj] looks up nested path [obj.a.b.c].

     

       469
       469
       +
             Returns [None] if any key is not found. *)

     

       470
       470
       +
       

     

       471
       471
       +
         val get_path_exn : string list -> t -> t

     

       472
       472
       +
         (** Like {!get_path} but raises [Not_found] if path not found. *)

     

       473
       473
       +
       

     

       474
       474
       +
         (** {3 Iteration} *)

     

       475
       475
       +
       

     

       476
       476
       +
         val iter_obj : (string -> t -> unit) -> t -> unit

     

       477
       477
       +
         (** [iter_obj f obj] calls [f key value] for each pair in [obj].

     

       478
       478
       +
             @raise Type_error if [obj] is not an object *)

     

       479
       479
       +
       

     

       480
       480
       +
         val iter_list : (t -> unit) -> t -> unit

     

       481
       481
       +
         (** [iter_list f lst] calls [f] on each element of [lst].

     

       482
       482
       +
             @raise Type_error if [lst] is not a list *)

     

       483
       483
       +
       

     

       484
       484
       +
         val fold_obj : ('a -> string -> t -> 'a) -> 'a -> t -> 'a

     

       485
       485
       +
         (** [fold_obj f init obj] folds over object key-value pairs.

     

       486
       486
       +
             @raise Type_error if [obj] is not an object *)

     

       487
       487
       +
       

     

       488
       488
       +
         (** {3 Mapping} *)

     

       489
       489
       +
       

     

       490
       490
       +
         val map_obj : (string -> t -> t) -> t -> t

     

       491
       491
       +
         (** [map_obj f obj] maps [f key value] over each pair in [obj].

     

       492
       492
       +
             @raise Type_error if [obj] is not an object *)

     

       493
       493
       +
       

     

       494
       494
       +
         val filter_obj : (string -> t -> bool) -> t -> t

     

       495
       495
       +
         (** [filter_obj pred obj] keeps pairs satisfying [pred key value].

     

       496
       496
       +
             @raise Type_error if [obj] is not an object *)

     

       497
       497
       +
       

     

       498
       498
       +
         (** {3 Conversion Helpers}

     

       499
       499
       +
       

     

       500
       500
       +
             Get values with optional defaults. If no default is provided and the type

     

       501
       501
       +
             doesn't match, these raise {!Type_error}. *)

     

       502
       502
       +
       

     

       503
       503
       +
         val to_bool : ?default:bool -> t -> bool

     

       504
       504
       +
         (** Get boolean or return default.

     

       505
       505
       +
             @raise Type_error if type doesn't match and no default provided *)

     

       506
       506
       +
       

     

       507
       507
       +
         val to_int : ?default:int -> t -> int

     

       508
       508
       +
         (** Get integer or return default.

     

       509
       509
       +
             @raise Type_error if type doesn't match and no default provided *)

     

       510
       510
       +
       

     

       511
       511
       +
         val to_float : ?default:float -> t -> float

     

       512
       512
       +
         (** Get float or return default.

     

       513
       513
       +
             @raise Type_error if type doesn't match and no default provided *)

     

       514
       514
       +
       

     

       515
       515
       +
         val to_string : ?default:string -> t -> string

     

       516
       516
       +
         (** Get string or return default.

     

       517
       517
       +
             @raise Type_error if type doesn't match and no default provided *)

     

       518
       518
       +
       

     

       519
       519
       +
         val to_list : ?default:t list -> t -> t list

     

       520
       520
       +
         (** Get list or return default.

     

       521
       521
       +
             @raise Type_error if type doesn't match and no default provided *)

     

       522
       522
       +
       end

     

       523
       523
       +
       

     

       524
       524
       +
       

     

       525
       525
       +
       (** {2 Stream - Low-Level Event API}

     

       526
       526
       +
       

     

       527
       527
       +
           Low-level streaming API for event-based YAML processing.

     

       528
       528
       +
       

     

       529
       529
       +
           This is useful for:

     

       530
       530
       +
           - Processing very large YAML files incrementally

     

       531
       531
       +
           - Building custom YAML transformers

     

       532
       532
       +
           - Fine-grained control over YAML emission *)

     

       533
       533
       +
       

     

       534
       534
       +
       module Stream : sig

     

       535
       535
       +
       

     

       536
       536
       +
         (** {3 Event Types} *)

     

       537
       537
       +
       

     

       538
       538
       +
         type event = Event.t

     

       539
       539
       +
         (** A parsing or emitting event. *)

     

       540
       540
       +
       

     

       541
       541
       +
         type position = Position.t

     

       542
       542
       +
         (** A position in the source (line, column, byte offset). *)

     

       543
       543
       +
       

     

       544
       544
       +
         type event_result = {

     

       545
       545
       +
           event : event;

     

       546
       546
       +
           start_pos : position;

     

       547
       547
       +
           end_pos : position;

     

       548
       548
       +
         }

     

       549
       549
       +
         (** Result of parsing an event with its source location. *)

     

       550
       550
       +
       

     

       551
       551
       +
         (** {3 Parsing} *)

     

       552
       552
       +
       

     

       553
       553
       +
         type parser

     

       554
       554
       +
         (** A streaming YAML parser. *)

     

       555
       555
       +
       

     

       556
       556
       +
         val parser : string -> parser

     

       557
       557
       +
         (** Create a parser from a string. *)

     

       558
       558
       +
       

     

       559
       559
       +
         val next : parser -> event_result option

     

       560
       560
       +
         (** Get the next event from the parser.

     

       561
       561
       +
             Returns [None] when parsing is complete. *)

     

       562
       562
       +
       

     

       563
       563
       +
         val iter : (event -> position -> position -> unit) -> parser -> unit

     

       564
       564
       +
         (** [iter f parser] calls [f event start_pos end_pos] for each event. *)

     

       565
       565
       +
       

     

       566
       566
       +
         val fold : ('a -> event -> 'a) -> 'a -> parser -> 'a

     

       567
       567
       +
         (** [fold f init parser] folds [f] over all events. *)

     

       568
       568
       +
       

     

       569
       569
       +
         (** {3 Emitting} *)

     

       570
       570
       +
       

     

       571
       571
       +
         type emitter

     

       572
       572
       +
         (** A streaming YAML emitter. *)

     

       573
       573
       +
       

     

       574
       574
       +
         val emitter : ?len:int -> unit -> emitter

     

       575
       575
       +
         (** Create a new emitter. *)

     

       576
       576
       +
       

     

       577
       577
       +
         val contents : emitter -> string

     

       578
       578
       +
         (** Get the emitted YAML string. *)

     

       579
       579
       +
       

     

       580
       580
       +
         val emit : emitter -> event -> unit

     

       581
       581
       +
         (** Emit an event.

     

       582
       582
       +
             @raise Yamlrw_error if the event sequence is invalid *)

     

       583
       583
       +
       

     

       584
       584
       +
         (** {3 Event Emission Helpers} *)

     

       585
       585
       +
       

     

       586
       586
       +
         val stream_start : emitter -> Encoding.t -> unit

     

       587
       587
       +
         (** Emit a stream start event. *)

     

       588
       588
       +
       

     

       589
       589
       +
         val stream_end : emitter -> unit

     

       590
       590
       +
         (** Emit a stream end event. *)

     

       591
       591
       +
       

     

       592
       592
       +
         val document_start : emitter -> ?version:version -> ?implicit:bool -> unit -> unit

     

       593
       593
       +
         (** Emit a document start event.

     

       594
       594
       +
             @param version YAML version directive

     

       595
       595
       +
             @param implicit Whether start marker is implicit (default: true) *)

     

       596
       596
       +
       

     

       597
       597
       +
         val document_end : emitter -> ?implicit:bool -> unit -> unit

     

       598
       598
       +
         (** Emit a document end event.

     

       599
       599
       +
             @param implicit Whether end marker is implicit (default: true) *)

     

       600
       600
       +
       

     

       601
       601
       +
         val scalar : emitter -> ?anchor:string -> ?tag:string -> ?style:Scalar_style.t -> string -> unit

     

       602
       602
       +
         (** Emit a scalar value.

     

       603
       603
       +
             @param anchor Optional anchor name

     

       604
       604
       +
             @param tag Optional type tag

     

       605
       605
       +
             @param style Scalar style (default: Any) *)

     

       606
       606
       +
       

     

       607
       607
       +
         val alias : emitter -> string -> unit

     

       608
       608
       +
         (** Emit an alias reference. *)

     

       609
       609
       +
       

     

       610
       610
       +
         val sequence_start : emitter -> ?anchor:string -> ?tag:string -> ?style:Layout_style.t -> unit -> unit

     

       611
       611
       +
         (** Emit a sequence start event.

     

       612
       612
       +
             @param anchor Optional anchor name

     

       613
       613
       +
             @param tag Optional type tag

     

       614
       614
       +
             @param style Layout style (default: Any) *)

     

       615
       615
       +
       

     

       616
       616
       +
         val sequence_end : emitter -> unit

     

       617
       617
       +
         (** Emit a sequence end event. *)

     

       618
       618
       +
       

     

       619
       619
       +
         val mapping_start : emitter -> ?anchor:string -> ?tag:string -> ?style:Layout_style.t -> unit -> unit

     

       620
       620
       +
         (** Emit a mapping start event.

     

       621
       621
       +
             @param anchor Optional anchor name

     

       622
       622
       +
             @param tag Optional type tag

     

       623
       623
       +
             @param style Layout style (default: Any) *)

     

       624
       624
       +
       

     

       625
       625
       +
         val mapping_end : emitter -> unit

     

       626
       626
       +
         (** Emit a mapping end event. *)

     

       627
       627
       +
       end

     

       628
       628
       +
       

     

       629
       629
       +
       

     

       630
       630
       +
       (** {2 Internal Modules}

     

       631
       631
       +
       

     

       632
       632
       +
           These modules are exposed for advanced use cases requiring

     

       633
       633
       +
           fine-grained control over parsing, emission, or data structures.

     

       634
       634
       +
       

     

       635
       635
       +
           For typical usage, prefer the top-level functions and {!Util}. *)

     

       636
       636
       +
       

     

       637
       637
       +
       module Position = Position

     

       638
       638
       +
       (** Source position tracking. *)

     

       639
       639
       +
       

     

       640
       640
       +
       module Span = Span

     

       641
       641
       +
       (** Source span (range of positions). *)

     

       642
       642
       +
       

     

       643
       643
       +
       module Chomping = Chomping

     

       644
       644
       +
       (** Block scalar chomping modes. *)

     

       645
       645
       +
       

     

       646
       646
       +
       module Tag = Tag

     

       647
       647
       +
       (** YAML type tags. *)

     

       648
       648
       +
       

     

       649
       649
       +
       module Value = Value

     

       650
       650
       +
       (** JSON-compatible value type and operations. *)

     

       651
       651
       +
       

     

       652
       652
       +
       module Scalar = Scalar

     

       653
       653
       +
       (** YAML scalar with metadata. *)

     

       654
       654
       +
       

     

       655
       655
       +
       module Sequence = Sequence

     

       656
       656
       +
       (** YAML sequence with metadata. *)

     

       657
       657
       +
       

     

       658
       658
       +
       module Mapping = Mapping

     

       659
       659
       +
       (** YAML mapping with metadata. *)

     

       660
       660
       +
       

     

       661
       661
       +
       module Yaml = Yaml

     

       662
       662
       +
       (** Full YAML value type. *)

     

       663
       663
       +
       

     

       664
       664
       +
       module Document = Document

     

       665
       665
       +
       (** YAML document with directives. *)

     

       666
       666
       +
       

     

       667
       667
       +
       module Token = Token

     

       668
       668
       +
       (** Lexical tokens. *)

     

       669
       669
       +
       

     

       670
       670
       +
       module Scanner = Scanner

     

       671
       671
       +
       (** Lexical scanner. *)

     

       672
       672
       +
       

     

       673
       673
       +
       module Event = Event

     

       674
       674
       +
       (** Parser events. *)

     

       675
       675
       +
       

     

       676
       676
       +
       module Parser = Parser

     

       677
       677
       +
       (** Event-based parser. *)

     

       678
       678
       +
       

     

       679
       679
       +
       module Loader = Loader

     

       680
       680
       +
       (** Document loader. *)

     

       681
       681
       +
       

     

       682
       682
       +
       module Emitter = Emitter

     

       683
       683
       +
       (** Event-based emitter. *)

     

       684
       684
       +
       

     

       685
       685
       +
       module Input = Input

     

       686
       686
       +
       (** Input stream utilities. *)

     

       687
       687
       +
       

     

       688
       688
       +
       module Serialize = Serialize

     

       689
       689
       +
       (** Buffer serialization utilities. *)

+24

tests/cram/anchor.yml

···

       1
       1
       +
       datetime: 2001-12-15T02:59:43.1Z

     

       2
       2
       +
       datetime_with_spaces: 2001-12-14 21:59:43.10 -5

     

       3
       3
       +
       date: 2002-12-14

     

       4
       4
       +
       

     

       5
       5
       +
       # The !!binary tag indicates that a string is actually a base64-encoded

     

       6
       6
       +
       # representation of a binary blob.

     

       7
       7
       +
       gif_file: !!binary |

     

       8
       8
       +
           R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5

     

       9
       9
       +
           OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+

     

       10
       10
       +
           +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC

     

       11
       11
       +
           AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=

     

       12
       12
       +
       

     

       13
       13
       +
       # YAML also has a set type, which looks like this:

     

       14
       14
       +
       set:

     

       15
       15
       +
           ? item1

     

       16
       16
       +
           ? item2

     

       17
       17
       +
           ? item3

     

       18
       18
       +
       

     

       19
       19
       +
       # Like Python, sets are just maps with null values; the above is equivalent to:

     

       20
       20
       +
       set2:

     

       21
       21
       +
           item1: null

     

       22
       22
       +
           item2: null

     

       23
       23
       +
           item3: null

     

       24
       24
       +

+375

tests/cram/anchors.t

···

       1
       1
       +
       Anchor and Alias Support (currently not supported)

     

       2
       2
       +
       

     

       3
       3
       +
       These tests document anchor (&) and alias (*) support that is not yet

     

       4
       4
       +
       implemented. Currently, aliases fail with "unresolved alias" error.

     

       5
       5
       +
       

     

       6
       6
       +
       Test: Simple scalar anchor and alias

     

       7
       7
       +
       

     

       8
       8
       +
         $ echo 'anchor: &anc value

     

       9
       9
       +
         > alias: *anc' | yamlcat 2>&1

     

       10
       10
       +
         anchor: value

     

       11
       11
       +
         alias: value

     

       12
       12
       +
       

     

       13
       13
       +
       Test: Numeric anchor and alias

     

       14
       14
       +
       

     

       15
       15
       +
         $ echo 'original: &num 42

     

       16
       16
       +
         > copy: *num' | yamlcat 2>&1

     

       17
       17
       +
         original: 42

     

       18
       18
       +
         copy: 42

     

       19
       19
       +
       

     

       20
       20
       +
       Test: Sequence anchor and alias

     

       21
       21
       +
       

     

       22
       22
       +
         $ echo 'list: &items

     

       23
       23
       +
         >   - one

     

       24
       24
       +
         >   - two

     

       25
       25
       +
         > copy: *items' | yamlcat 2>&1

     

       26
       26
       +
         list:

     

       27
       27
       +
           - one

     

       28
       28
       +
           - two

     

       29
       29
       +
         copy:

     

       30
       30
       +
           - one

     

       31
       31
       +
           - two

     

       32
       32
       +
       

     

       33
       33
       +
       Test: Mapping anchor and alias

     

       34
       34
       +
       

     

       35
       35
       +
         $ echo 'person: &p

     

       36
       36
       +
         >   name: Alice

     

       37
       37
       +
         >   age: 30

     

       38
       38
       +
         > copy: *p' | yamlcat 2>&1

     

       39
       39
       +
         person:

     

       40
       40
       +
           name: Alice

     

       41
       41
       +
           age: 30

     

       42
       42
       +
         copy:

     

       43
       43
       +
           name: Alice

     

       44
       44
       +
           age: 30

     

       45
       45
       +
       

     

       46
       46
       +
       Test: Multiple aliases to same anchor

     

       47
       47
       +
       

     

       48
       48
       +
         $ echo 'value: &v 100

     

       49
       49
       +
         > first: *v

     

       50
       50
       +
         > second: *v

     

       51
       51
       +
         > third: *v' | yamlcat 2>&1

     

       52
       52
       +
         value: 100

     

       53
       53
       +
         first: 100

     

       54
       54
       +
         second: 100

     

       55
       55
       +
         third: 100

     

       56
       56
       +
       

     

       57
       57
       +
       Test: Anchor in flow context

     

       58
       58
       +
       

     

       59
       59
       +
         $ echo '[&item apple, *item]' | yamlcat 2>&1

     

       60
       60
       +
         - apple

     

       61
       61
       +
         - apple

     

       62
       62
       +
       

     

       63
       63
       +
       Test: Anchor with mapping in flow

     

       64
       64
       +
       

     

       65
       65
       +
         $ echo '{original: &cfg {a: 1}, copy: *cfg}' | yamlcat 2>&1

     

       66
       66
       +
         original:

     

       67
       67
       +
           a: 1

     

       68
       68
       +
         copy:

     

       69
       69
       +
           a: 1

     

       70
       70
       +
       

     

       71
       71
       +
       Test: Anchors file from test suite

     

       72
       72
       +
       

     

       73
       73
       +
         $ yamlcat anchors_basic.yml 2>&1

     

       74
       74
       +
         scalar_anchor: Hello, World!

     

       75
       75
       +
         scalar_alias: Hello, World!

     

       76
       76
       +
         ---

     

       77
       77
       +
         original: 42

     

       78
       78
       +
         copy: 42

     

       79
       79
       +
         another_copy: 42

     

       80
       80
       +
         ---

     

       81
       81
       +
         original_list:

     

       82
       82
       +
           - apple

     

       83
       83
       +
           - banana

     

       84
       84
       +
           - cherry

     

       85
       85
       +
         copied_list:

     

       86
       86
       +
           - apple

     

       87
       87
       +
           - banana

     

       88
       88
       +
           - cherry

     

       89
       89
       +
         ---

     

       90
       90
       +
         original_map:

     

       91
       91
       +
           name: Alice

     

       92
       92
       +
           age: 30

     

       93
       93
       +
           city: London

     

       94
       94
       +
         copied_map:

     

       95
       95
       +
           name: Alice

     

       96
       96
       +
           age: 30

     

       97
       97
       +
           city: London

     

       98
       98
       +
         ---

     

       99
       99
       +
         defaults:

     

       100
       100
       +
           timeout: 30

     

       101
       101
       +
           retries: 3

     

       102
       102
       +
         colors:

     

       103
       103
       +
           - red

     

       104
       104
       +
           - green

     

       105
       105
       +
           - blue

     

       106
       106
       +
         config:

     

       107
       107
       +
           settings:

     

       108
       108
       +
             timeout: 30

     

       109
       109
       +
             retries: 3

     

       110
       110
       +
           palette:

     

       111
       111
       +
             - red

     

       112
       112
       +
             - green

     

       113
       113
       +
             - blue

     

       114
       114
       +
         ---

     

       115
       115
       +
         template:

     

       116
       116
       +
           metadata:

     

       117
       117
       +
             version: 1

     

       118
       118
       +
             author: John Doe

     

       119
       119
       +
           settings:

     

       120
       120
       +
             enabled: true

     

       121
       121
       +
             debug: false

     

       122
       122
       +
         instance1:

     

       123
       123
       +
           metadata:

     

       124
       124
       +
             version: 1

     

       125
       125
       +
             author: John Doe

     

       126
       126
       +
           settings:

     

       127
       127
       +
             enabled: true

     

       128
       128
       +
             debug: false

     

       129
       129
       +
         instance2:

     

       130
       130
       +
           metadata:

     

       131
       131
       +
             version: 1

     

       132
       132
       +
             author: John Doe

     

       133
       133
       +
           settings:

     

       134
       134
       +
             enabled: true

     

       135
       135
       +
             debug: false

     

       136
       136
       +
         ---

     

       137
       137
       +
         items:

     

       138
       138
       +
           - id: 1

     

       139
       139
       +
             name: First

     

       140
       140
       +
           - id: 2

     

       141
       141
       +
             name: Second

     

       142
       142
       +
           - id: 1

     

       143
       143
       +
             name: First

     

       144
       144
       +
         ---

     

       145
       145
       +
         shared_value: 100

     

       146
       146
       +
         calculations:

     

       147
       147
       +
           base: 100

     

       148
       148
       +
           doubled: 200

     

       149
       149
       +
           reference: 100

     

       150
       150
       +
           another_ref: 100

     

       151
       151
       +
         ---

     

       152
       152
       +
         feature_flag: true

     

       153
       153
       +
         features:

     

       154
       154
       +
           login: true

     

       155
       155
       +
           signup: true

     

       156
       156
       +
           export: true

     

       157
       157
       +
         ---

     

       158
       158
       +
         empty: null

     

       159
       159
       +
         values:

     

       160
       160
       +
           first: null

     

       161
       161
       +
           second: null

     

       162
       162
       +
         ---

     

       163
       163
       +
         message: "This is a multi-line\nmessage with some\nspecial content!\n"

     

       164
       164
       +
         output1: "This is a multi-line\nmessage with some\nspecial content!\n"

     

       165
       165
       +
         output2: "This is a multi-line\nmessage with some\nspecial content!\n"

     

       166
       166
       +
         ---

     

       167
       167
       +
         database:

     

       168
       168
       +
           primary:

     

       169
       169
       +
             host: localhost

     

       170
       170
       +
             port: 5432

     

       171
       171
       +
             ssl: true

     

       172
       172
       +
           replica:

     

       173
       173
       +
             host: localhost

     

       174
       174
       +
             port: 5432

     

       175
       175
       +
             ssl: true

     

       176
       176
       +
           backup:

     

       177
       177
       +
             host: localhost

     

       178
       178
       +
             port: 5432

     

       179
       179
       +
             ssl: true

     

       180
       180
       +
       

     

       181
       181
       +
         $ yamlcat anchors_merge.yml 2>&1

     

       182
       182
       +
         defaults:

     

       183
       183
       +
           timeout: 30

     

       184
       184
       +
           retries: 3

     

       185
       185
       +
           verbose: false

     

       186
       186
       +
         production:

     

       187
       187
       +
           <<:

     

       188
       188
       +
             timeout: 30

     

       189
       189
       +
             retries: 3

     

       190
       190
       +
             verbose: false

     

       191
       191
       +
           environment: production

     

       192
       192
       +
         ---

     

       193
       193
       +
         base:

     

       194
       194
       +
           color: red

     

       195
       195
       +
           size: medium

     

       196
       196
       +
           weight: 100

     

       197
       197
       +
         custom:

     

       198
       198
       +
           <<:

     

       199
       199
       +
             color: red

     

       200
       200
       +
             size: medium

     

       201
       201
       +
             weight: 100

     

       202
       202
       +
           color: blue

     

       203
       203
       +
           shape: circle

     

       204
       204
       +
         ---

     

       205
       205
       +
         connection:

     

       206
       206
       +
           host: localhost

     

       207
       207
       +
           port: 8080

     

       208
       208
       +
         authentication:

     

       209
       209
       +
           username: admin

     

       210
       210
       +
           password: secret

     

       211
       211
       +
         server:

     

       212
       212
       +
           <<:

     

       213
       213
       +
             - host: localhost

     

       214
       214
       +
               port: 8080

     

       215
       215
       +
             - username: admin

     

       216
       216
       +
               password: secret

     

       217
       217
       +
           ssl: true

     

       218
       218
       +
         ---

     

       219
       219
       +
         defaults:

     

       220
       220
       +
           timeout: 30

     

       221
       221
       +
           retries: 3

     

       222
       222
       +
         advanced:

     

       223
       223
       +
           cache: true

     

       224
       224
       +
           pool_size: 10

     

       225
       225
       +
         config:

     

       226
       226
       +
           <<:

     

       227
       227
       +
             - timeout: 30

     

       228
       228
       +
               retries: 3

     

       229
       229
       +
             - cache: true

     

       230
       230
       +
               pool_size: 10

     

       231
       231
       +
           timeout: 60

     

       232
       232
       +
           custom: value

     

       233
       233
       +
         ---

     

       234
       234
       +
         base_style:

     

       235
       235
       +
           font: Arial

     

       236
       236
       +
           size: 12

     

       237
       237
       +
         heading_defaults:

     

       238
       238
       +
           <<:

     

       239
       239
       +
             font: Arial

     

       240
       240
       +
             size: 12

     

       241
       241
       +
           weight: bold

     

       242
       242
       +
         main_heading:

     

       243
       243
       +
           <<:

     

       244
       244
       +
             <<:

     

       245
       245
       +
               font: Arial

     

       246
       246
       +
               size: 12

     

       247
       247
       +
             weight: bold

     

       248
       248
       +
           size: 18

     

       249
       249
       +
           color: navy

     

       250
       250
       +
         ---

     

       251
       251
       +
         common:

     

       252
       252
       +
           enabled: true

     

       253
       253
       +
           log_level: info

     

       254
       254
       +
         services:

     

       255
       255
       +
           - name: web

     

       256
       256
       +
             <<:

     

       257
       257
       +
               enabled: true

     

       258
       258
       +
               log_level: info

     

       259
       259
       +
             port: 80

     

       260
       260
       +
           - name: api

     

       261
       261
       +
             <<:

     

       262
       262
       +
               enabled: true

     

       263
       263
       +
               log_level: info

     

       264
       264
       +
             port: 3000

     

       265
       265
       +
           - name: worker

     

       266
       266
       +
             <<:

     

       267
       267
       +
               enabled: true

     

       268
       268
       +
               log_level: info

     

       269
       269
       +
             threads: 4

     

       270
       270
       +
         ---

     

       271
       271
       +
         empty: {}

     

       272
       272
       +
         config:

     

       273
       273
       +
           <<: {}

     

       274
       274
       +
           key: value

     

       275
       275
       +
         ---

     

       276
       276
       +
         metadata:

     

       277
       277
       +
           created: 2023-01-01

     

       278
       278
       +
           author: Admin

     

       279
       279
       +
           tags:

     

       280
       280
       +
             - v1

     

       281
       281
       +
             - stable

     

       282
       282
       +
         document:

     

       283
       283
       +
           <<:

     

       284
       284
       +
             created: 2023-01-01

     

       285
       285
       +
             author: Admin

     

       286
       286
       +
             tags:

     

       287
       287
       +
               - v1

     

       288
       288
       +
               - stable

     

       289
       289
       +
           title: Important Document

     

       290
       290
       +
           content: Some content here

     

       291
       291
       +
         ---

     

       292
       292
       +
         level1:

     

       293
       293
       +
           a: 1

     

       294
       294
       +
           b: 2

     

       295
       295
       +
         level2:

     

       296
       296
       +
           <<:

     

       297
       297
       +
             a: 1

     

       298
       298
       +
             b: 2

     

       299
       299
       +
           c: 3

     

       300
       300
       +
         level3:

     

       301
       301
       +
           <<:

     

       302
       302
       +
             <<:

     

       303
       303
       +
               a: 1

     

       304
       304
       +
               b: 2

     

       305
       305
       +
             c: 3

     

       306
       306
       +
           d: 4

     

       307
       307
       +
         ---

     

       308
       308
       +
         first:

     

       309
       309
       +
           name: First

     

       310
       310
       +
           value: 100

     

       311
       311
       +
           priority: low

     

       312
       312
       +
         second:

     

       313
       313
       +
           name: Second

     

       314
       314
       +
           value: 200

     

       315
       315
       +
           category: important

     

       316
       316
       +
         combined:

     

       317
       317
       +
           <<:

     

       318
       318
       +
             - name: First

     

       319
       319
       +
               value: 100

     

       320
       320
       +
               priority: low

     

       321
       321
       +
             - name: Second

     

       322
       322
       +
               value: 200

     

       323
       323
       +
               category: important

     

       324
       324
       +
           name: Combined

     

       325
       325
       +
         ---

     

       326
       326
       +
         numbers:

     

       327
       327
       +
           count: 42

     

       328
       328
       +
           ratio: 3.14

     

       329
       329
       +
           active: true

     

       330
       330
       +
         derived:

     

       331
       331
       +
           <<:

     

       332
       332
       +
             count: 42

     

       333
       333
       +
             ratio: 3.14

     

       334
       334
       +
             active: true

     

       335
       335
       +
           label: Test

     

       336
       336
       +
         ---

     

       337
       337
       +
         db_defaults:

     

       338
       338
       +
           pool_size: 5

     

       339
       339
       +
           timeout: 30

     

       340
       340
       +
           ssl: false

     

       341
       341
       +
         cache_defaults:

     

       342
       342
       +
           ttl: 3600

     

       343
       343
       +
           max_size: 1000

     

       344
       344
       +
         development:

     

       345
       345
       +
           database:

     

       346
       346
       +
             <<:

     

       347
       347
       +
               pool_size: 5

     

       348
       348
       +
               timeout: 30

     

       349
       349
       +
               ssl: false

     

       350
       350
       +
             host: localhost

     

       351
       351
       +
             name: dev_db

     

       352
       352
       +
           cache:

     

       353
       353
       +
             <<:

     

       354
       354
       +
               ttl: 3600

     

       355
       355
       +
               max_size: 1000

     

       356
       356
       +
             backend: memory

     

       357
       357
       +
         production:

     

       358
       358
       +
           database:

     

       359
       359
       +
             <<:

     

       360
       360
       +
               pool_size: 5

     

       361
       361
       +
               timeout: 30

     

       362
       362
       +
               ssl: false

     

       363
       363
       +
             host: prod.example.com

     

       364
       364
       +
             name: prod_db

     

       365
       365
       +
             ssl: true

     

       366
       366
       +
             pool_size: 20

     

       367
       367
       +
           cache:

     

       368
       368
       +
             <<:

     

       369
       369
       +
               ttl: 3600

     

       370
       370
       +
               max_size: 1000

     

       371
       371
       +
             backend: redis

     

       372
       372
       +
             ttl: 7200

     

       373
       373
       +
       

     

       374
       374
       +
       Note: The anchor test files also use multiple documents, so they fail

     

       375
       375
       +
       with multi-document errors before even hitting anchor issues.

+125

tests/cram/anchors_basic.yml

···

       1
       1
       +
       # Basic Anchor and Alias Test Cases

     

       2
       2
       +
       # Tests fundamental anchor (&) and alias (*) functionality

     

       3
       3
       +
       

     

       4
       4
       +
       # Test 1: Simple scalar anchor and alias

     

       5
       5
       +
       ---

     

       6
       6
       +
       scalar_anchor: &simple_scalar "Hello, World!"

     

       7
       7
       +
       scalar_alias: *simple_scalar

     

       8
       8
       +
       # Expected: both should have the value "Hello, World!"

     

       9
       9
       +
       

     

       10
       10
       +
       # Test 2: Numeric scalar anchor

     

       11
       11
       +
       ---

     

       12
       12
       +
       original: &num 42

     

       13
       13
       +
       copy: *num

     

       14
       14
       +
       another_copy: *num

     

       15
       15
       +
       # Expected: all three should have the value 42

     

       16
       16
       +
       

     

       17
       17
       +
       # Test 3: Sequence anchor and alias

     

       18
       18
       +
       ---

     

       19
       19
       +
       original_list: &my_list

     

       20
       20
       +
         - apple

     

       21
       21
       +
         - banana

     

       22
       22
       +
         - cherry

     

       23
       23
       +
       

     

       24
       24
       +
       copied_list: *my_list

     

       25
       25
       +
       # Expected: both lists should be identical

     

       26
       26
       +
       

     

       27
       27
       +
       # Test 4: Mapping anchor and alias

     

       28
       28
       +
       ---

     

       29
       29
       +
       original_map: &person

     

       30
       30
       +
         name: Alice

     

       31
       31
       +
         age: 30

     

       32
       32
       +
         city: London

     

       33
       33
       +
       

     

       34
       34
       +
       copied_map: *person

     

       35
       35
       +
       # Expected: both maps should be identical

     

       36
       36
       +
       

     

       37
       37
       +
       # Test 5: Multiple anchors in same document

     

       38
       38
       +
       ---

     

       39
       39
       +
       defaults: &defaults

     

       40
       40
       +
         timeout: 30

     

       41
       41
       +
         retries: 3

     

       42
       42
       +
       

     

       43
       43
       +
       colors: &colors

     

       44
       44
       +
         - red

     

       45
       45
       +
         - green

     

       46
       46
       +
         - blue

     

       47
       47
       +
       

     

       48
       48
       +
       config:

     

       49
       49
       +
         settings: *defaults

     

       50
       50
       +
         palette: *colors

     

       51
       51
       +
       # Expected: config.settings should have timeout and retries, config.palette should have the color list

     

       52
       52
       +
       

     

       53
       53
       +
       # Test 6: Nested structure with anchor

     

       54
       54
       +
       ---

     

       55
       55
       +
       template: &template

     

       56
       56
       +
         metadata:

     

       57
       57
       +
           version: 1.0

     

       58
       58
       +
           author: John Doe

     

       59
       59
       +
         settings:

     

       60
       60
       +
           enabled: true

     

       61
       61
       +
           debug: false

     

       62
       62
       +
       

     

       63
       63
       +
       instance1: *template

     

       64
       64
       +
       instance2: *template

     

       65
       65
       +
       # Expected: both instances should be identical copies of template

     

       66
       66
       +
       

     

       67
       67
       +
       # Test 7: Anchor in sequence

     

       68
       68
       +
       ---

     

       69
       69
       +
       items:

     

       70
       70
       +
         - &first_item

     

       71
       71
       +
           id: 1

     

       72
       72
       +
           name: First

     

       73
       73
       +
         - id: 2

     

       74
       74
       +
           name: Second

     

       75
       75
       +
         - *first_item

     

       76
       76
       +
       # Expected: first and third items should be identical

     

       77
       77
       +
       

     

       78
       78
       +
       # Test 8: Multiple uses of same alias

     

       79
       79
       +
       ---

     

       80
       80
       +
       shared_value: &shared 100

     

       81
       81
       +
       calculations:

     

       82
       82
       +
         base: *shared

     

       83
       83
       +
         doubled: 200  # Just a value, not calculated

     

       84
       84
       +
         reference: *shared

     

       85
       85
       +
         another_ref: *shared

     

       86
       86
       +
       # Expected: base, reference, and another_ref should all be 100

     

       87
       87
       +
       

     

       88
       88
       +
       # Test 9: Boolean anchor

     

       89
       89
       +
       ---

     

       90
       90
       +
       feature_flag: &enabled true

     

       91
       91
       +
       features:

     

       92
       92
       +
         login: *enabled

     

       93
       93
       +
         signup: *enabled

     

       94
       94
       +
         export: *enabled

     

       95
       95
       +
       # Expected: all features should be true

     

       96
       96
       +
       

     

       97
       97
       +
       # Test 10: Null anchor

     

       98
       98
       +
       ---

     

       99
       99
       +
       empty: &null_value ~

     

       100
       100
       +
       values:

     

       101
       101
       +
         first: *null_value

     

       102
       102
       +
         second: *null_value

     

       103
       103
       +
       # Expected: all should be null

     

       104
       104
       +
       

     

       105
       105
       +
       # Test 11: String with special characters

     

       106
       106
       +
       ---

     

       107
       107
       +
       message: &msg |

     

       108
       108
       +
         This is a multi-line

     

       109
       109
       +
         message with some

     

       110
       110
       +
         special content!

     

       111
       111
       +
       

     

       112
       112
       +
       output1: *msg

     

       113
       113
       +
       output2: *msg

     

       114
       114
       +
       # Expected: both outputs should have the same multi-line string

     

       115
       115
       +
       

     

       116
       116
       +
       # Test 12: Anchor in mapping value

     

       117
       117
       +
       ---

     

       118
       118
       +
       database:

     

       119
       119
       +
         primary: &db_config

     

       120
       120
       +
           host: localhost

     

       121
       121
       +
           port: 5432

     

       122
       122
       +
           ssl: true

     

       123
       123
       +
         replica: *db_config

     

       124
       124
       +
         backup: *db_config

     

       125
       125
       +
       # Expected: primary, replica, and backup should all have identical configuration

+194

tests/cram/anchors_merge.yml

···

       1
       1
       +
       # Merge Key Test Cases

     

       2
       2
       +
       # Tests YAML 1.1 merge key (<<) functionality

     

       3
       3
       +
       # Note: Merge keys are a YAML 1.1 feature and may not be supported in YAML 1.2

     

       4
       4
       +
       

     

       5
       5
       +
       # Test 1: Basic merge key

     

       6
       6
       +
       ---

     

       7
       7
       +
       defaults: &defaults

     

       8
       8
       +
         timeout: 30

     

       9
       9
       +
         retries: 3

     

       10
       10
       +
         verbose: false

     

       11
       11
       +
       

     

       12
       12
       +
       production:

     

       13
       13
       +
         <<: *defaults

     

       14
       14
       +
         environment: production

     

       15
       15
       +
       # Expected: production should have timeout, retries, verbose from defaults, plus environment

     

       16
       16
       +
       

     

       17
       17
       +
       # Test 2: Override after merge

     

       18
       18
       +
       ---

     

       19
       19
       +
       base: &base

     

       20
       20
       +
         color: red

     

       21
       21
       +
         size: medium

     

       22
       22
       +
         weight: 100

     

       23
       23
       +
       

     

       24
       24
       +
       custom:

     

       25
       25
       +
         <<: *base

     

       26
       26
       +
         color: blue

     

       27
       27
       +
         shape: circle

     

       28
       28
       +
       # Expected: custom should have size and weight from base, but color should be blue, and add shape

     

       29
       29
       +
       

     

       30
       30
       +
       # Test 3: Merging multiple anchors

     

       31
       31
       +
       ---

     

       32
       32
       +
       connection: &connection

     

       33
       33
       +
         host: localhost

     

       34
       34
       +
         port: 8080

     

       35
       35
       +
       

     

       36
       36
       +
       authentication: &auth

     

       37
       37
       +
         username: admin

     

       38
       38
       +
         password: secret

     

       39
       39
       +
       

     

       40
       40
       +
       server:

     

       41
       41
       +
         <<: [*connection, *auth]

     

       42
       42
       +
         ssl: true

     

       43
       43
       +
       # Expected: server should have host, port, username, password, and ssl

     

       44
       44
       +
       

     

       45
       45
       +
       # Test 4: Multiple merges with override

     

       46
       46
       +
       ---

     

       47
       47
       +
       defaults: &defaults

     

       48
       48
       +
         timeout: 30

     

       49
       49
       +
         retries: 3

     

       50
       50
       +
       

     

       51
       51
       +
       advanced: &advanced

     

       52
       52
       +
         cache: true

     

       53
       53
       +
         pool_size: 10

     

       54
       54
       +
       

     

       55
       55
       +
       config:

     

       56
       56
       +
         <<: [*defaults, *advanced]

     

       57
       57
       +
         timeout: 60

     

       58
       58
       +
         custom: value

     

       59
       59
       +
       # Expected: config should have all fields from both anchors, with timeout overridden to 60

     

       60
       60
       +
       

     

       61
       61
       +
       # Test 5: Nested merge

     

       62
       62
       +
       ---

     

       63
       63
       +
       base_style: &base_style

     

       64
       64
       +
         font: Arial

     

       65
       65
       +
         size: 12

     

       66
       66
       +
       

     

       67
       67
       +
       heading_defaults: &heading

     

       68
       68
       +
         <<: *base_style

     

       69
       69
       +
         weight: bold

     

       70
       70
       +
       

     

       71
       71
       +
       main_heading:

     

       72
       72
       +
         <<: *heading

     

       73
       73
       +
         size: 18

     

       74
       74
       +
         color: navy

     

       75
       75
       +
       # Expected: main_heading should inherit from heading (which inherits from base_style) with overrides

     

       76
       76
       +
       

     

       77
       77
       +
       # Test 6: Merge in sequence context

     

       78
       78
       +
       ---

     

       79
       79
       +
       common: &common

     

       80
       80
       +
         enabled: true

     

       81
       81
       +
         log_level: info

     

       82
       82
       +
       

     

       83
       83
       +
       services:

     

       84
       84
       +
         - name: web

     

       85
       85
       +
           <<: *common

     

       86
       86
       +
           port: 80

     

       87
       87
       +
         - name: api

     

       88
       88
       +
           <<: *common

     

       89
       89
       +
           port: 3000

     

       90
       90
       +
         - name: worker

     

       91
       91
       +
           <<: *common

     

       92
       92
       +
           threads: 4

     

       93
       93
       +
       # Expected: each service should have enabled and log_level, plus their specific fields

     

       94
       94
       +
       

     

       95
       95
       +
       # Test 7: Empty merge (edge case)

     

       96
       96
       +
       ---

     

       97
       97
       +
       empty: &empty {}

     

       98
       98
       +
       

     

       99
       99
       +
       config:

     

       100
       100
       +
         <<: *empty

     

       101
       101
       +
         key: value

     

       102
       102
       +
       # Expected: config should just have key: value

     

       103
       103
       +
       

     

       104
       104
       +
       # Test 8: Merge with nested structures

     

       105
       105
       +
       ---

     

       106
       106
       +
       metadata: &metadata

     

       107
       107
       +
         created: 2023-01-01

     

       108
       108
       +
         author: Admin

     

       109
       109
       +
         tags:

     

       110
       110
       +
           - v1

     

       111
       111
       +
           - stable

     

       112
       112
       +
       

     

       113
       113
       +
       document:

     

       114
       114
       +
         <<: *metadata

     

       115
       115
       +
         title: Important Document

     

       116
       116
       +
         content: Some content here

     

       117
       117
       +
       # Expected: document should have all metadata fields plus title and content

     

       118
       118
       +
       

     

       119
       119
       +
       # Test 9: Chain of merges

     

       120
       120
       +
       ---

     

       121
       121
       +
       level1: &l1

     

       122
       122
       +
         a: 1

     

       123
       123
       +
         b: 2

     

       124
       124
       +
       

     

       125
       125
       +
       level2: &l2

     

       126
       126
       +
         <<: *l1

     

       127
       127
       +
         c: 3

     

       128
       128
       +
       

     

       129
       129
       +
       level3:

     

       130
       130
       +
         <<: *l2

     

       131
       131
       +
         d: 4

     

       132
       132
       +
       # Expected: level3 should have a, b, c, and d

     

       133
       133
       +
       

     

       134
       134
       +
       # Test 10: Merge with conflicting keys

     

       135
       135
       +
       ---

     

       136
       136
       +
       first: &first

     

       137
       137
       +
         name: First

     

       138
       138
       +
         value: 100

     

       139
       139
       +
         priority: low

     

       140
       140
       +
       

     

       141
       141
       +
       second: &second

     

       142
       142
       +
         name: Second

     

       143
       143
       +
         value: 200

     

       144
       144
       +
         category: important

     

       145
       145
       +
       

     

       146
       146
       +
       combined:

     

       147
       147
       +
         <<: [*first, *second]

     

       148
       148
       +
         name: Combined

     

       149
       149
       +
       # Expected: later merges and direct assignments take precedence

     

       150
       150
       +
       

     

       151
       151
       +
       # Test 11: Merge preserving types

     

       152
       152
       +
       ---

     

       153
       153
       +
       numbers: &numbers

     

       154
       154
       +
         count: 42

     

       155
       155
       +
         ratio: 3.14

     

       156
       156
       +
         active: true

     

       157
       157
       +
       

     

       158
       158
       +
       derived:

     

       159
       159
       +
         <<: *numbers

     

       160
       160
       +
         label: Test

     

       161
       161
       +
       # Expected: types should be preserved (int, float, bool)

     

       162
       162
       +
       

     

       163
       163
       +
       # Test 12: Complex real-world example

     

       164
       164
       +
       ---

     

       165
       165
       +
       db_defaults: &db_defaults

     

       166
       166
       +
         pool_size: 5

     

       167
       167
       +
         timeout: 30

     

       168
       168
       +
         ssl: false

     

       169
       169
       +
       

     

       170
       170
       +
       cache_defaults: &cache_defaults

     

       171
       171
       +
         ttl: 3600

     

       172
       172
       +
         max_size: 1000

     

       173
       173
       +
       

     

       174
       174
       +
       development:

     

       175
       175
       +
         database:

     

       176
       176
       +
           <<: *db_defaults

     

       177
       177
       +
           host: localhost

     

       178
       178
       +
           name: dev_db

     

       179
       179
       +
         cache:

     

       180
       180
       +
           <<: *cache_defaults

     

       181
       181
       +
           backend: memory

     

       182
       182
       +
       

     

       183
       183
       +
       production:

     

       184
       184
       +
         database:

     

       185
       185
       +
           <<: *db_defaults

     

       186
       186
       +
           host: prod.example.com

     

       187
       187
       +
           name: prod_db

     

       188
       188
       +
           ssl: true

     

       189
       189
       +
           pool_size: 20

     

       190
       190
       +
         cache:

     

       191
       191
       +
           <<: *cache_defaults

     

       192
       192
       +
           backend: redis

     

       193
       193
       +
           ttl: 7200

     

       194
       194
       +
       # Expected: each environment should inherit defaults with environment-specific overrides

+70

tests/cram/bomb.t

···

       1
       1
       +
       Billion laughs attack protection tests

     

       2
       2
       +
       

     

       3
       3
       +
       Test with a tight node limit (small bomb would expand to ~6561 nodes):

     

       4
       4
       +
       

     

       5
       5
       +
         $ yamlcat --max-nodes 100 --json bomb_small.yml

     

       6
       6
       +
         Error: alias expansion exceeded node limit (100 nodes)

     

       7
       7
       +
         [1]

     

       8
       8
       +
       

     

       9
       9
       +
       Test with a limit that allows the small bomb:

     

       10
       10
       +
       

     

       11
       11
       +
         $ yamlcat --max-nodes 10000 --json bomb_small.yml | head -c 100

     

       12
       12
       +
         {"a": [1, 2, 3, 4, 5, 6, 7, 8, 9], "b": [[1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [

     

       13
       13
       +
       

     

       14
       14
       +
       Test depth limit with a nested alias chain:

     

       15
       15
       +
       

     

       16
       16
       +
         $ yamlcat --max-depth 2 --json depth_bomb.yml | head -c 50

     

       17
       17
       +
         {"a": ["x", "y", "z"], "b": [["x", "y", "z"], ["x"

     

       18
       18
       +
       

     

       19
       19
       +
         $ yamlcat --max-depth 10 --json depth_bomb.yml | head -c 50

     

       20
       20
       +
         {"a": ["x", "y", "z"], "b": [["x", "y", "z"], ["x"

     

       21
       21
       +
       

     

       22
       22
       +
       Test that --no-resolve-aliases keeps aliases as-is (in debug mode):

     

       23
       23
       +
       

     

       24
       24
       +
         $ yamlcat --no-resolve-aliases --debug simple_alias.yml

     

       25
       25
       +
         Document 1:

     

       26
       26
       +
         document(

     

       27
       27
       +
           implicit_start=true,

     

       28
       28
       +
           implicit_end=true,

     

       29
       29
       +
           root=mapping(

     

       30
       30
       +
                  style=block,

     

       31
       31
       +
                  members={

     

       32
       32
       +
                  scalar("anchor", style=plain):

     

       33
       33
       +
                    scalar("hello", anchor=anc, style=plain),

     

       34
       34
       +
                  scalar("alias", style=plain): *anc

     

       35
       35
       +
           })

     

       36
       36
       +
         )

     

       37
       37
       +
       

     

       38
       38
       +
       With resolve (default), aliases are expanded:

     

       39
       39
       +
       

     

       40
       40
       +
         $ yamlcat --json simple_alias.yml

     

       41
       41
       +
         {"anchor": "hello", "alias": "hello"}

     

       42
       42
       +
       

     

       43
       43
       +
       Test the full bomb is rejected with default limits:

     

       44
       44
       +
       

     

       45
       45
       +
         $ yamlcat --json bomb.yml 2>&1 | head -1

     

       46
       46
       +
         Error: alias expansion exceeded node limit (10000000 nodes)

     

       47
       47
       +
       

     

       48
       48
       +
       With a very small limit:

     

       49
       49
       +
       

     

       50
       50
       +
         $ yamlcat --max-nodes 50 --json bomb.yml

     

       51
       51
       +
         Error: alias expansion exceeded node limit (50 nodes)

     

       52
       52
       +
         [1]

     

       53
       53
       +
       

     

       54
       54
       +
       Test that valid YAML with aliases works:

     

       55
       55
       +
       

     

       56
       56
       +
         $ yamlcat --json valid_alias.yml

     

       57
       57
       +
         {"defaults": {"timeout": 30, "retries": 3}, "production": {"<<": {"timeout": 30, "retries": 3}, "port": 8080}}

     

       58
       58
       +
       

     

       59
       59
       +
       Test help includes the new options:

     

       60
       60
       +
       

     

       61
       61
       +
         $ yamlcat --help=plain | grep 'max-nodes'

     

       62
       62
       +
                --max-nodes=N (absent=10000000)

     

       63
       63
       +
                  yamlcat --max-nodes 1000 --max-depth 10 untrusted.yaml

     

       64
       64
       +
       

     

       65
       65
       +
         $ yamlcat --help=plain | grep 'max-depth'

     

       66
       66
       +
                --max-depth=N (absent=100)

     

       67
       67
       +
                  yamlcat --max-nodes 1000 --max-depth 10 untrusted.yaml

     

       68
       68
       +
       

     

       69
       69
       +
         $ yamlcat --help=plain | grep 'no-resolve-aliases'

     

       70
       70
       +
                --no-resolve-aliases

tests/cram/bomb.yml

···

       1
       1
       +
       a: &a ["lol","lol","lol","lol","lol","lol","lol","lol","lol"]

     

       2
       2
       +
       b: &b [*a,*a,*a,*a,*a,*a,*a,*a,*a]

     

       3
       3
       +
       c: &c [*b,*b,*b,*b,*b,*b,*b,*b,*b]

     

       4
       4
       +
       d: &d [*c,*c,*c,*c,*c,*c,*c,*c,*c]

     

       5
       5
       +
       e: &e [*d,*d,*d,*d,*d,*d,*d,*d,*d]

     

       6
       6
       +
       f: &f [*e,*e,*e,*e,*e,*e,*e,*e,*e]

     

       7
       7
       +
       g: &g [*f,*f,*f,*f,*f,*f,*f,*f,*f]

     

       8
       8
       +
       h: &h [*g,*g,*g,*g,*g,*g,*g,*g,*g]

     

       9
       9
       +
       i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h]

tests/cram/bomb_small.yml

···

       1
       1
       +
       # Small "billion laughs" style YAML bomb for testing

     

       2
       2
       +
       # Expands to 9^4 = 6561 nodes when aliases are resolved

     

       3
       3
       +
       a: &a [1, 2, 3, 4, 5, 6, 7, 8, 9]

     

       4
       4
       +
       b: &b [*a, *a, *a, *a, *a, *a, *a, *a, *a]

     

       5
       5
       +
       c: &c [*b, *b, *b, *b, *b, *b, *b, *b, *b]

     

       6
       6
       +
       d: &d [*c, *c, *c, *c, *c, *c, *c, *c, *c]

+23

tests/cram/cohttp.yml

···

       1
       1
       +
       language: c

     

       2
       2
       +
       sudo: false

     

       3
       3
       +
       services:

     

       4
       4
       +
         - docker

     

       5
       5
       +
       install: wget https://raw.githubusercontent.com/ocaml/ocaml-travisci-skeleton/master/.travis-docker.sh

     

       6
       6
       +
       script: bash -ex ./.travis-docker.sh

     

       7
       7
       +
       env:

     

       8
       8
       +
         global:

     

       9
       9
       +
         - EXTRA_REMOTES="https://github.com/mirage/mirage-dev.git"

     

       10
       10
       +
         - PINS="cohttp-top:. cohttp-async:. cohttp-lwt-unix:. cohttp-lwt-jsoo:. cohttp-lwt:. cohttp-mirage:. cohttp:."

     

       11
       11
       +
         matrix:

     

       12
       12
       +
         - PACKAGE="cohttp" DISTRO="alpine-3.5" OCAML_VERSION="4.06.0"

     

       13
       13
       +
         - PACKAGE="cohttp-async" DISTRO="alpine" OCAML_VERSION="4.06.0"

     

       14
       14
       +
         - PACKAGE="cohttp-lwt" DISTRO="debian-unstable" OCAML_VERSION="4.03.0"

     

       15
       15
       +
         - PACKAGE="cohttp-mirage" DISTRO="debian-unstable" OCAML_VERSION="4.03.0"

     

       16
       16
       +
       notifications:

     

       17
       17
       +
         webhooks:

     

       18
       18
       +
           urls:

     

       19
       19
       +
             - https://webhooks.gitter.im/e/6ee5059c7420709f4ad1

     

       20
       20
       +
           on_success: change

     

       21
       21
       +
           on_failure: always

     

       22
       22
       +
           on_start: false

     

       23
       23
       +

+863

tests/cram/collections.t

···

       1
       1
       +
       Test collections_block.yml - Block style collections

     

       2
       2
       +
       

     

       3
       3
       +
         $ yamlcat collections_block.yml

     

       4
       4
       +
         simple_sequence:

     

       5
       5
       +
           - apple

     

       6
       6
       +
           - banana

     

       7
       7
       +
           - cherry

     

       8
       8
       +
           - date

     

       9
       9
       +
         simple_mapping:

     

       10
       10
       +
           name: John Doe

     

       11
       11
       +
           age: 30

     

       12
       12
       +
           city: New York

     

       13
       13
       +
           country: USA

     

       14
       14
       +
         nested_sequences:

     

       15
       15
       +
           - 

     

       16
       16
       +
             - alpha

     

       17
       17
       +
             - beta

     

       18
       18
       +
             - gamma

     

       19
       19
       +
           - 

     

       20
       20
       +
             - one

     

       21
       21
       +
             - two

     

       22
       22
       +
             - three

     

       23
       23
       +
           - 

     

       24
       24
       +
             - red

     

       25
       25
       +
             - green

     

       26
       26
       +
             - blue

     

       27
       27
       +
         nested_mappings:

     

       28
       28
       +
           person:

     

       29
       29
       +
             name: Alice

     

       30
       30
       +
             contact:

     

       31
       31
       +
               email: alice@example.com

     

       32
       32
       +
               phone: 555-1234

     

       33
       33
       +
             address:

     

       34
       34
       +
               street: 123 Main St

     

       35
       35
       +
               city: Boston

     

       36
       36
       +
         mapping_with_sequences:

     

       37
       37
       +
           colors:

     

       38
       38
       +
             - red

     

       39
       39
       +
             - green

     

       40
       40
       +
             - blue

     

       41
       41
       +
           sizes:

     

       42
       42
       +
             - small

     

       43
       43
       +
             - medium

     

       44
       44
       +
             - large

     

       45
       45
       +
           numbers:

     

       46
       46
       +
             - 1

     

       47
       47
       +
             - 2

     

       48
       48
       +
             - 3

     

       49
       49
       +
         sequence_with_mappings:

     

       50
       50
       +
           - name: Alice

     

       51
       51
       +
             age: 25

     

       52
       52
       +
             role: developer

     

       53
       53
       +
           - name: Bob

     

       54
       54
       +
             age: 30

     

       55
       55
       +
             role: designer

     

       56
       56
       +
           - name: Charlie

     

       57
       57
       +
             age: 35

     

       58
       58
       +
             role: manager

     

       59
       59
       +
         deep_nesting:

     

       60
       60
       +
           level1:

     

       61
       61
       +
             level2:

     

       62
       62
       +
               level3:

     

       63
       63
       +
                 level4:

     

       64
       64
       +
                   - deeply

     

       65
       65
       +
                   - nested

     

       66
       66
       +
                   - values

     

       67
       67
       +
                 another_key: value

     

       68
       68
       +
               items:

     

       69
       69
       +
                 - item1

     

       70
       70
       +
                 - item2

     

       71
       71
       +
             metadata:

     

       72
       72
       +
               created: 2024-01-01

     

       73
       73
       +
               modified: 2024-12-04

     

       74
       74
       +
         complex_structure:

     

       75
       75
       +
           database:

     

       76
       76
       +
             connections:

     

       77
       77
       +
               - host: db1.example.com

     

       78
       78
       +
                 port: 5432

     

       79
       79
       +
                 credentials:

     

       80
       80
       +
                   username: admin

     

       81
       81
       +
                   password: secret

     

       82
       82
       +
               - host: db2.example.com

     

       83
       83
       +
                 port: 5432

     

       84
       84
       +
                 credentials:

     

       85
       85
       +
                   username: readonly

     

       86
       86
       +
                   password: public

     

       87
       87
       +
           services:

     

       88
       88
       +
             - name: api

     

       89
       89
       +
               endpoints:

     

       90
       90
       +
                 - /users

     

       91
       91
       +
                 - /posts

     

       92
       92
       +
                 - /comments

     

       93
       93
       +
               config:

     

       94
       94
       +
                 timeout: 30

     

       95
       95
       +
                 retries: 3

     

       96
       96
       +
             - name: worker

     

       97
       97
       +
               tasks:

     

       98
       98
       +
                 - email

     

       99
       99
       +
                 - reports

     

       100
       100
       +
               config:

     

       101
       101
       +
                 concurrency: 10

     

       102
       102
       +
         empty_collections:

     

       103
       103
       +
           empty_sequence: []

     

       104
       104
       +
           empty_mapping: {}

     

       105
       105
       +
           sequence_with_empty:

     

       106
       106
       +
             - value1

     

       107
       107
       +
             - []

     

       108
       108
       +
             - value2

     

       109
       109
       +
           mapping_with_empty:

     

       110
       110
       +
             key1: value1

     

       111
       111
       +
             key2: {}

     

       112
       112
       +
             key3: value3

     

       113
       113
       +
       

     

       114
       114
       +
       Test collections_block.yml with JSON output

     

       115
       115
       +
       

     

       116
       116
       +
         $ yamlcat --json collections_block.yml

     

       117
       117
       +
         {"simple_sequence": ["apple", "banana", "cherry", "date"], "simple_mapping": {"name": "John Doe", "age": 30, "city": "New York", "country": "USA"}, "nested_sequences": [["alpha", "beta", "gamma"], ["one", "two", "three"], ["red", "green", "blue"]], "nested_mappings": {"person": {"name": "Alice", "contact": {"email": "alice@example.com", "phone": "555-1234"}, "address": {"street": "123 Main St", "city": "Boston"}}}, "mapping_with_sequences": {"colors": ["red", "green", "blue"], "sizes": ["small", "medium", "large"], "numbers": [1, 2, 3]}, "sequence_with_mappings": [{"name": "Alice", "age": 25, "role": "developer"}, {"name": "Bob", "age": 30, "role": "designer"}, {"name": "Charlie", "age": 35, "role": "manager"}], "deep_nesting": {"level1": {"level2": {"level3": {"level4": ["deeply", "nested", "values"], "another_key": "value"}, "items": ["item1", "item2"]}, "metadata": {"created": "2024-01-01", "modified": "2024-12-04"}}}, "complex_structure": {"database": {"connections": [{"host": "db1.example.com", "port": 5432, "credentials": {"username": "admin", "password": "secret"}}, {"host": "db2.example.com", "port": 5432, "credentials": {"username": "readonly", "password": "public"}}]}, "services": [{"name": "api", "endpoints": ["/users", "/posts", "/comments"], "config": {"timeout": 30, "retries": 3}}, {"name": "worker", "tasks": ["email", "reports"], "config": {"concurrency": 10}}]}, "empty_collections": {"empty_sequence": [], "empty_mapping": {}, "sequence_with_empty": ["value1", [], "value2"], "mapping_with_empty": {"key1": "value1", "key2": {}, "key3": "value3"}}}

     

       118
       118
       +
       

     

       119
       119
       +
       Test collections_block.yml with flow output

     

       120
       120
       +
       

     

       121
       121
       +
         $ yamlcat --flow collections_block.yml

     

       122
       122
       +
         {simple_sequence: [apple, banana, cherry, date]simple_mapping, {name: John Doe, age: 30, city: New York, country: USA}, nested_sequences: [[alpha, beta, gamma], [one, two, three], [red, green, blue]]nested_mappings, {person: {name: Alice, contact: {email: alice@example.com, phone: 555-1234}address, {street: 123 Main St, city: Boston}}}, mapping_with_sequences: {colors: [red, green, blue]sizes, [small, medium, large], numbers: [1, 2, 3]}sequence_with_mappings, [{name: Alice, age: 25, role: developer}, {name: Bob, age: 30, role: designer}, {name: Charlie, age: 35, role: manager}], deep_nesting: {level1: {level2: {level3: {level4: [deeply, nested, values]another_key, value: }items, [item1, item2]}metadata, {created: 2024-01-01, modified: 2024-12-04}}}complex_structure, {database: {connections: [{host: db1.example.com, port: 5432, credentials: {username: admin, password: secret}}, {host: db2.example.com, port: 5432, credentials: {username: readonly, password: public}}]}services, [{name: api, endpoints: [/users, /posts, /comments]config, {timeout: 30, retries: 3}}, {name: worker, tasks: [email, reports]config, {concurrency: 10}}]}, empty_collections: {empty_sequence: []empty_mapping, {}, sequence_with_empty: [value1, [], value2]mapping_with_empty, {key1: value1, key2: {}key3, value3: }}}

     

       123
       123
       +
       

     

       124
       124
       +
       Test collections_compact.yml - Compact notation

     

       125
       125
       +
       

     

       126
       126
       +
         $ yamlcat collections_compact.yml

     

       127
       127
       +
         compact_sequence:

     

       128
       128
       +
           - name: Alice

     

       129
       129
       +
             age: 25

     

       130
       130
       +
             city: Boston

     

       131
       131
       +
           - name: Bob

     

       132
       132
       +
             age: 30

     

       133
       133
       +
             city: Seattle

     

       134
       134
       +
           - name: Charlie

     

       135
       135
       +
             age: 35

     

       136
       136
       +
             city: Portland

     

       137
       137
       +
         compact_nested:

     

       138
       138
       +
           - id: 1

     

       139
       139
       +
             details:

     

       140
       140
       +
               type: admin

     

       141
       141
       +
               permissions:

     

       142
       142
       +
                 - read

     

       143
       143
       +
                 - write

     

       144
       144
       +
                 - delete

     

       145
       145
       +
           - id: 2

     

       146
       146
       +
             details:

     

       147
       147
       +
               type: user

     

       148
       148
       +
               permissions:

     

       149
       149
       +
                 - read

     

       150
       150
       +
         compact_complex:

     

       151
       151
       +
           - key1: value1

     

       152
       152
       +
             key2: value2

     

       153
       153
       +
             nested:

     

       154
       154
       +
               sub1: val1

     

       155
       155
       +
               sub2: val2

     

       156
       156
       +
           - key1: value3

     

       157
       157
       +
             key2: value4

     

       158
       158
       +
             nested:

     

       159
       159
       +
               sub1: val3

     

       160
       160
       +
               sub2: val4

     

       161
       161
       +
         users:

     

       162
       162
       +
           - username: alice

     

       163
       163
       +
             email: alice@example.com

     

       164
       164
       +
             active: true

     

       165
       165
       +
           - username: bob

     

       166
       166
       +
             email: bob@example.com

     

       167
       167
       +
             active: false

     

       168
       168
       +
         compact_with_flow:

     

       169
       169
       +
           - name: service1

     

       170
       170
       +
             ports:

     

       171
       171
       +
               - 8080

     

       172
       172
       +
               - 8443

     

       173
       173
       +
             env:

     

       174
       174
       +
               DEBUG: true

     

       175
       175
       +
               MODE: production

     

       176
       176
       +
           - name: service2

     

       177
       177
       +
             ports:

     

       178
       178
       +
               - 3000

     

       179
       179
       +
             env:

     

       180
       180
       +
               DEBUG: false

     

       181
       181
       +
               MODE: development

     

       182
       182
       +
         deep_compact:

     

       183
       183
       +
           - category: electronics

     

       184
       184
       +
             items:

     

       185
       185
       +
               - name: laptop

     

       186
       186
       +
                 specs:

     

       187
       187
       +
                   cpu: Intel i7

     

       188
       188
       +
                   ram: 16GB

     

       189
       189
       +
                   storage: 512GB SSD

     

       190
       190
       +
               - name: phone

     

       191
       191
       +
                 specs:

     

       192
       192
       +
                   os: Android

     

       193
       193
       +
                   ram: 8GB

     

       194
       194
       +
                   storage: 256GB

     

       195
       195
       +
           - category: furniture

     

       196
       196
       +
             items:

     

       197
       197
       +
               - name: desk

     

       198
       198
       +
                 dimensions:

     

       199
       199
       +
                   width: 150cm

     

       200
       200
       +
                   depth: 75cm

     

       201
       201
       +
                   height: 75cm

     

       202
       202
       +
               - name: chair

     

       203
       203
       +
                 dimensions:

     

       204
       204
       +
                   width: 60cm

     

       205
       205
       +
                   depth: 60cm

     

       206
       206
       +
                   height: 120cm

     

       207
       207
       +
         mixed_compact:

     

       208
       208
       +
           databases:

     

       209
       209
       +
             - type: postgresql

     

       210
       210
       +
               connection:

     

       211
       211
       +
                 host: localhost

     

       212
       212
       +
                 port: 5432

     

       213
       213
       +
               credentials:

     

       214
       214
       +
                 user: admin

     

       215
       215
       +
                 password: secret

     

       216
       216
       +
             - type: mongodb

     

       217
       217
       +
               connection:

     

       218
       218
       +
                 host: localhost

     

       219
       219
       +
                 port: 27017

     

       220
       220
       +
               credentials:

     

       221
       221
       +
                 user: root

     

       222
       222
       +
                 password: root

     

       223
       223
       +
         single_line_compact:

     

       224
       224
       +
           - name: Alice

     

       225
       225
       +
             age: 25

     

       226
       226
       +
             role: developer

     

       227
       227
       +
           - name: Bob

     

       228
       228
       +
             age: 30

     

       229
       229
       +
             role: designer

     

       230
       230
       +
           - name: Charlie

     

       231
       231
       +
             age: 35

     

       232
       232
       +
             role: manager

     

       233
       233
       +
         sequences_in_compact:

     

       234
       234
       +
           - title: Project A

     

       235
       235
       +
             members:

     

       236
       236
       +
               - Alice

     

       237
       237
       +
               - Bob

     

       238
       238
       +
               - Charlie

     

       239
       239
       +
             tags:

     

       240
       240
       +
               - urgent

     

       241
       241
       +
               - backend

     

       242
       242
       +
           - title: Project B

     

       243
       243
       +
             members:

     

       244
       244
       +
               - David

     

       245
       245
       +
               - Eve

     

       246
       246
       +
             tags:

     

       247
       247
       +
               - frontend

     

       248
       248
       +
               - design

     

       249
       249
       +
         compact_with_empty:

     

       250
       250
       +
           - id: 1

     

       251
       251
       +
             data: []

     

       252
       252
       +
             meta: {}

     

       253
       253
       +
           - id: 2

     

       254
       254
       +
             data:

     

       255
       255
       +
               - item1

     

       256
       256
       +
             meta:

     

       257
       257
       +
               key: value

     

       258
       258
       +
         compact_complex_nesting:

     

       259
       259
       +
           - level: 1

     

       260
       260
       +
             children:

     

       261
       261
       +
               - level: 2a

     

       262
       262
       +
                 children:

     

       263
       263
       +
                   - level: 3a

     

       264
       264
       +
                     value: leaf1

     

       265
       265
       +
                   - level: 3b

     

       266
       266
       +
                     value: leaf2

     

       267
       267
       +
               - level: 2b

     

       268
       268
       +
                 children:

     

       269
       269
       +
                   - level: 3c

     

       270
       270
       +
                     value: leaf3

     

       271
       271
       +
         api_endpoints:

     

       272
       272
       +
           - path: /users

     

       273
       273
       +
             method: GET

     

       274
       274
       +
             auth: required

     

       275
       275
       +
             params:

     

       276
       276
       +
               - name: page

     

       277
       277
       +
                 type: integer

     

       278
       278
       +
                 default: 1

     

       279
       279
       +
               - name: limit

     

       280
       280
       +
                 type: integer

     

       281
       281
       +
                 default: 10

     

       282
       282
       +
           - path: '/users/:id'

     

       283
       283
       +
             method: GET

     

       284
       284
       +
             auth: required

     

       285
       285
       +
             params: []

     

       286
       286
       +
           - path: /users

     

       287
       287
       +
             method: POST

     

       288
       288
       +
             auth: required

     

       289
       289
       +
             body:

     

       290
       290
       +
               username: string

     

       291
       291
       +
               email: string

     

       292
       292
       +
               password: string

     

       293
       293
       +
         compact_types:

     

       294
       294
       +
           - string_val: hello

     

       295
       295
       +
             number_val: 42

     

       296
       296
       +
             float_val: 3.14

     

       297
       297
       +
             bool_val: true

     

       298
       298
       +
             null_val: null

     

       299
       299
       +
           - string_val: world

     

       300
       300
       +
             number_val: 100

     

       301
       301
       +
             float_val: 2.71

     

       302
       302
       +
             bool_val: false

     

       303
       303
       +
             null_val: null

     

       304
       304
       +
         minimal:

     

       305
       305
       +
           - a: 1

     

       306
       306
       +
           - b: 2

     

       307
       307
       +
           - c: 3

     

       308
       308
       +
       

     

       309
       309
       +
       Test collections_compact.yml with JSON output

     

       310
       310
       +
       

     

       311
       311
       +
         $ yamlcat --json collections_compact.yml

     

       312
       312
       +
         {"compact_sequence": [{"name": "Alice", "age": 25, "city": "Boston"}, {"name": "Bob", "age": 30, "city": "Seattle"}, {"name": "Charlie", "age": 35, "city": "Portland"}], "compact_nested": [{"id": 1, "details": {"type": "admin", "permissions": ["read", "write", "delete"]}}, {"id": 2, "details": {"type": "user", "permissions": ["read"]}}], "compact_complex": [{"key1": "value1", "key2": "value2", "nested": {"sub1": "val1", "sub2": "val2"}}, {"key1": "value3", "key2": "value4", "nested": {"sub1": "val3", "sub2": "val4"}}], "users": [{"username": "alice", "email": "alice@example.com", "active": true}, {"username": "bob", "email": "bob@example.com", "active": false}], "compact_with_flow": [{"name": "service1", "ports": [8080, 8443], "env": {"DEBUG": true, "MODE": "production"}}, {"name": "service2", "ports": [3000], "env": {"DEBUG": false, "MODE": "development"}}], "deep_compact": [{"category": "electronics", "items": [{"name": "laptop", "specs": {"cpu": "Intel i7", "ram": "16GB", "storage": "512GB SSD"}}, {"name": "phone", "specs": {"os": "Android", "ram": "8GB", "storage": "256GB"}}]}, {"category": "furniture", "items": [{"name": "desk", "dimensions": {"width": "150cm", "depth": "75cm", "height": "75cm"}}, {"name": "chair", "dimensions": {"width": "60cm", "depth": "60cm", "height": "120cm"}}]}], "mixed_compact": {"databases": [{"type": "postgresql", "connection": {"host": "localhost", "port": 5432}, "credentials": {"user": "admin", "password": "secret"}}, {"type": "mongodb", "connection": {"host": "localhost", "port": 27017}, "credentials": {"user": "root", "password": "root"}}]}, "single_line_compact": [{"name": "Alice", "age": 25, "role": "developer"}, {"name": "Bob", "age": 30, "role": "designer"}, {"name": "Charlie", "age": 35, "role": "manager"}], "sequences_in_compact": [{"title": "Project A", "members": ["Alice", "Bob", "Charlie"], "tags": ["urgent", "backend"]}, {"title": "Project B", "members": ["David", "Eve"], "tags": ["frontend", "design"]}], "compact_with_empty": [{"id": 1, "data": [], "meta": {}}, {"id": 2, "data": ["item1"], "meta": {"key": "value"}}], "compact_complex_nesting": [{"level": 1, "children": [{"level": "2a", "children": [{"level": "3a", "value": "leaf1"}, {"level": "3b", "value": "leaf2"}]}, {"level": "2b", "children": [{"level": "3c", "value": "leaf3"}]}]}], "api_endpoints": [{"path": "/users", "method": "GET", "auth": "required", "params": [{"name": "page", "type": "integer", "default": 1}, {"name": "limit", "type": "integer", "default": 10}]}, {"path": "/users/:id", "method": "GET", "auth": "required", "params": []}, {"path": "/users", "method": "POST", "auth": "required", "body": {"username": "string", "email": "string", "password": "string"}}], "compact_types": [{"string_val": "hello", "number_val": 42, "float_val": 3.14, "bool_val": true, "null_val": null}, {"string_val": "world", "number_val": 100, "float_val": 2.71, "bool_val": false, "null_val": null}], "minimal": [{"a": 1}, {"b": 2}, {"c": 3}]}

     

       313
       313
       +
       

     

       314
       314
       +
       Test collections_compact.yml with flow output

     

       315
       315
       +
       

     

       316
       316
       +
         $ yamlcat --flow collections_compact.yml

     

       317
       317
       +
         {compact_sequence: [{name: Alice, age: 25, city: Boston}, {name: Bob, age: 30, city: Seattle}, {name: Charlie, age: 35, city: Portland}]compact_nested, [{id: 1, details: {type: admin, permissions: [read, write, delete]}}, {id: 2, details: {type: user, permissions: [read]}}], compact_complex: [{key1: value1, key2: value2, nested: {sub1: val1, sub2: val2}}, {key1: value3, key2: value4, nested: {sub1: val3, sub2: val4}}]users, [{username: alice, email: alice@example.com, active: true}, {username: bob, email: bob@example.com, active: false}], compact_with_flow: [{name: service1, ports: [8080, 8443]env, {DEBUG: true, MODE: production}}, {name: service2, ports: [3000]env, {DEBUG: false, MODE: development}}]deep_compact, [{category: electronics, items: [{name: laptop, specs: {cpu: Intel i7, ram: 16GB, storage: 512GB SSD}}, {name: phone, specs: {os: Android, ram: 8GB, storage: 256GB}}]}, {category: furniture, items: [{name: desk, dimensions: {width: 150cm, depth: 75cm, height: 75cm}}, {name: chair, dimensions: {width: 60cm, depth: 60cm, height: 120cm}}]}], mixed_compact: {databases: [{type: postgresql, connection: {host: localhost, port: 5432}credentials, {user: admin, password: secret}}, {type: mongodb, connection: {host: localhost, port: 27017}credentials, {user: root, password: root}}]}single_line_compact, [{name: Alice, age: 25, role: developer}, {name: Bob, age: 30, role: designer}, {name: Charlie, age: 35, role: manager}], sequences_in_compact: [{title: Project A, members: [Alice, Bob, Charlie]tags, [urgent, backend]}, {title: Project B, members: [David, Eve]tags, [frontend, design]}]compact_with_empty, [{id: 1, data: []meta, {}}, {id: 2, data: [item1]meta, {key: value}}], compact_complex_nesting: [{level: 1, children: [{level: 2a, children: [{level: 3a, value: leaf1}, {level: 3b, value: leaf2}]}, {level: 2b, children: [{level: 3c, value: leaf3}]}]}]api_endpoints, [{path: /users, method: GET, auth: required, params: [{name: page, type: integer, default: 1}, {name: limit, type: integer, default: 10}]}, {path: '/users/:id', method: GET, auth: required, params: []}, {path: /users, method: POST, auth: required, body: {username: string, email: string, password: string}}], compact_types: [{string_val: hello, number_val: 42, float_val: 3.14, bool_val: true, null_val: null}, {string_val: world, number_val: 100, float_val: 2.71, bool_val: false, null_val: null}]minimal, [{a: 1}, {b: 2}, {c: 3}]}

     

       318
       318
       +
       

     

       319
       319
       +
       Test collections_flow.yml - Flow style collections

     

       320
       320
       +
       

     

       321
       321
       +
         $ yamlcat collections_flow.yml

     

       322
       322
       +
         simple_flow_sequence:

     

       323
       323
       +
           - apple

     

       324
       324
       +
           - banana

     

       325
       325
       +
           - cherry

     

       326
       326
       +
           - date

     

       327
       327
       +
         simple_flow_mapping:

     

       328
       328
       +
           name: John

     

       329
       329
       +
           age: 30

     

       330
       330
       +
           city: New York

     

       331
       331
       +
         nested_flow_sequences:

     

       332
       332
       +
           - 

     

       333
       333
       +
             - a

     

       334
       334
       +
             - b

     

       335
       335
       +
             - c

     

       336
       336
       +
           - 

     

       337
       337
       +
             - 1

     

       338
       338
       +
             - 2

     

       339
       339
       +
             - 3

     

       340
       340
       +
           - 

     

       341
       341
       +
             - red

     

       342
       342
       +
             - green

     

       343
       343
       +
             - blue

     

       344
       344
       +
         nested_flow_mappings:

     

       345
       345
       +
           person:

     

       346
       346
       +
             name: Alice

     

       347
       347
       +
             age: 25

     

       348
       348
       +
           contact:

     

       349
       349
       +
             email: alice@example.com

     

       350
       350
       +
             phone: 555-1234

     

       351
       351
       +
         flow_seq_with_maps:

     

       352
       352
       +
           - name: Alice

     

       353
       353
       +
             role: dev

     

       354
       354
       +
           - name: Bob

     

       355
       355
       +
             role: ops

     

       356
       356
       +
           - name: Charlie

     

       357
       357
       +
             role: qa

     

       358
       358
       +
         flow_map_with_seqs:

     

       359
       359
       +
           colors:

     

       360
       360
       +
             - red

     

       361
       361
       +
             - green

     

       362
       362
       +
             - blue

     

       363
       363
       +
           sizes:

     

       364
       364
       +
             - S

     

       365
       365
       +
             - M

     

       366
       366
       +
             - L

     

       367
       367
       +
           numbers:

     

       368
       368
       +
             - 1

     

       369
       369
       +
             - 2

     

       370
       370
       +
             - 3

     

       371
       371
       +
         deep_flow_nesting:

     

       372
       372
       +
           level1:

     

       373
       373
       +
             level2:

     

       374
       374
       +
               level3:

     

       375
       375
       +
                 level4:

     

       376
       376
       +
                   - a

     

       377
       377
       +
                   - b

     

       378
       378
       +
                   - c

     

       379
       379
       +
         empty_flow:

     

       380
       380
       +
           empty_seq: []

     

       381
       381
       +
           empty_map: {}

     

       382
       382
       +
           both:

     

       383
       383
       +
             - []

     

       384
       384
       +
             - {}

     

       385
       385
       +
         flow_in_block:

     

       386
       386
       +
           sequence:

     

       387
       387
       +
             - 1

     

       388
       388
       +
             - 2

     

       389
       389
       +
             - 3

     

       390
       390
       +
             - 4

     

       391
       391
       +
             - 5

     

       392
       392
       +
           mapping:

     

       393
       393
       +
             a: 1

     

       394
       394
       +
             b: 2

     

       395
       395
       +
             c: 3

     

       396
       396
       +
           nested:

     

       397
       397
       +
             items:

     

       398
       398
       +
               - x

     

       399
       399
       +
               - y

     

       400
       400
       +
               - z

     

       401
       401
       +
             config:

     

       402
       402
       +
               timeout: 30

     

       403
       403
       +
               retries: 3

     

       404
       404
       +
         block_in_flow:

     

       405
       405
       +
           users:

     

       406
       406
       +
             - name: Alice

     

       407
       407
       +
               tags:

     

       408
       408
       +
                 - dev

     

       409
       409
       +
                 - senior

     

       410
       410
       +
             - name: Bob

     

       411
       411
       +
               tags:

     

       412
       412
       +
                 - ops

     

       413
       413
       +
                 - junior

     

       414
       414
       +
         mixed_structure:

     

       415
       415
       +
           services:

     

       416
       416
       +
             - name: api

     

       417
       417
       +
               ports:

     

       418
       418
       +
                 - 8080

     

       419
       419
       +
                 - 8443

     

       420
       420
       +
               env:

     

       421
       421
       +
                 DEBUG: true

     

       422
       422
       +
                 LOG_LEVEL: info

     

       423
       423
       +
             - name: db

     

       424
       424
       +
               ports:

     

       425
       425
       +
                 - 5432

     

       426
       426
       +
               env:

     

       427
       427
       +
                 POSTGRES_DB: mydb

     

       428
       428
       +
                 POSTGRES_USER: admin

     

       429
       429
       +
           config:

     

       430
       430
       +
             version: 1

     

       431
       431
       +
             enabled: true

     

       432
       432
       +
         flow_types:

     

       433
       433
       +
           strings:

     

       434
       434
       +
             - hello

     

       435
       435
       +
             - world

     

       436
       436
       +
             - foo

     

       437
       437
       +
             - bar

     

       438
       438
       +
           numbers:

     

       439
       439
       +
             - 1

     

       440
       440
       +
             - 2

     

       441
       441
       +
             - 3

     

       442
       442
       +
             - 42

     

       443
       443
       +
             - 100

     

       444
       444
       +
           mixed:

     

       445
       445
       +
             - string

     

       446
       446
       +
             - 123

     

       447
       447
       +
             - true

     

       448
       448
       +
             - false

     

       449
       449
       +
             - null

     

       450
       450
       +
           quoted:

     

       451
       451
       +
             - with spaces

     

       452
       452
       +
             - 'special:chars'

     

       453
       453
       +
             - commas, here

     

       454
       454
       +
         flow_map_types:

     

       455
       455
       +
           string: value

     

       456
       456
       +
           number: 42

     

       457
       457
       +
           boolean: true

     

       458
       458
       +
           null_value: null

     

       459
       459
       +
           float: 3.14

     

       460
       460
       +
         nested_mixed:

     

       461
       461
       +
           - id: 1

     

       462
       462
       +
             data:

     

       463
       463
       +
               - a

     

       464
       464
       +
               - b

     

       465
       465
       +
               - c

     

       466
       466
       +
             meta:

     

       467
       467
       +
               type: first

     

       468
       468
       +
           - id: 2

     

       469
       469
       +
             data:

     

       470
       470
       +
               - d

     

       471
       471
       +
               - e

     

       472
       472
       +
               - f

     

       473
       473
       +
             meta:

     

       474
       474
       +
               type: second

     

       475
       475
       +
           - id: 3

     

       476
       476
       +
             data:

     

       477
       477
       +
               - g

     

       478
       478
       +
               - h

     

       479
       479
       +
               - i

     

       480
       480
       +
             meta:

     

       481
       481
       +
               type: third

     

       482
       482
       +
         multiline_flow:

     

       483
       483
       +
           long_sequence:

     

       484
       484
       +
             - item1

     

       485
       485
       +
             - item2

     

       486
       486
       +
             - item3

     

       487
       487
       +
             - item4

     

       488
       488
       +
           long_mapping:

     

       489
       489
       +
             key1: value1

     

       490
       490
       +
             key2: value2

     

       491
       491
       +
             key3: value3

     

       492
       492
       +
         edge_cases:

     

       493
       493
       +
           single_item_seq:

     

       494
       494
       +
             - alone

     

       495
       495
       +
           single_item_map:

     

       496
       496
       +
             only: one

     

       497
       497
       +
           nested_empty:

     

       498
       498
       +
             - []

     

       499
       499
       +
             - 

     

       500
       500
       +
               - {}

     

       501
       501
       +
             - 

     

       502
       502
       +
               - {}

     

       503
       503
       +
               - []

     

       504
       504
       +
           all_empty:

     

       505
       505
       +
             - {}

     

       506
       506
       +
             - []

     

       507
       507
       +
             - a: []

     

       508
       508
       +
             - b: {}

     

       509
       509
       +
       

     

       510
       510
       +
       Test collections_flow.yml with JSON output

     

       511
       511
       +
       

     

       512
       512
       +
         $ yamlcat --json collections_flow.yml

     

       513
       513
       +
         {"simple_flow_sequence": ["apple", "banana", "cherry", "date"], "simple_flow_mapping": {"name": "John", "age": 30, "city": "New York"}, "nested_flow_sequences": [["a", "b", "c"], [1, 2, 3], ["red", "green", "blue"]], "nested_flow_mappings": {"person": {"name": "Alice", "age": 25}, "contact": {"email": "alice@example.com", "phone": "555-1234"}}, "flow_seq_with_maps": [{"name": "Alice", "role": "dev"}, {"name": "Bob", "role": "ops"}, {"name": "Charlie", "role": "qa"}], "flow_map_with_seqs": {"colors": ["red", "green", "blue"], "sizes": ["S", "M", "L"], "numbers": [1, 2, 3]}, "deep_flow_nesting": {"level1": {"level2": {"level3": {"level4": ["a", "b", "c"]}}}}, "empty_flow": {"empty_seq": [], "empty_map": {}, "both": [[], {}]}, "flow_in_block": {"sequence": [1, 2, 3, 4, 5], "mapping": {"a": 1, "b": 2, "c": 3}, "nested": {"items": ["x", "y", "z"], "config": {"timeout": 30, "retries": 3}}}, "block_in_flow": {"users": [{"name": "Alice", "tags": ["dev", "senior"]}, {"name": "Bob", "tags": ["ops", "junior"]}]}, "mixed_structure": {"services": [{"name": "api", "ports": [8080, 8443], "env": {"DEBUG": true, "LOG_LEVEL": "info"}}, {"name": "db", "ports": [5432], "env": {"POSTGRES_DB": "mydb", "POSTGRES_USER": "admin"}}], "config": {"version": 1, "enabled": true}}, "flow_types": {"strings": ["hello", "world", "foo", "bar"], "numbers": [1, 2, 3, 42, 100], "mixed": ["string", 123, true, false, null], "quoted": ["with spaces", "special:chars", "commas, here"]}, "flow_map_types": {"string": "value", "number": 42, "boolean": true, "null_value": null, "float": 3.14}, "nested_mixed": [{"id": 1, "data": ["a", "b", "c"], "meta": {"type": "first"}}, {"id": 2, "data": ["d", "e", "f"], "meta": {"type": "second"}}, {"id": 3, "data": ["g", "h", "i"], "meta": {"type": "third"}}], "multiline_flow": {"long_sequence": ["item1", "item2", "item3", "item4"], "long_mapping": {"key1": "value1", "key2": "value2", "key3": "value3"}}, "edge_cases": {"single_item_seq": ["alone"], "single_item_map": {"only": "one"}, "nested_empty": [[], [{}], [{}, []]], "all_empty": [{}, [], {"a": []}, {"b": {}}]}}

     

       514
       514
       +
       

     

       515
       515
       +
       Test collections_flow.yml with flow output

     

       516
       516
       +
       

     

       517
       517
       +
         $ yamlcat --flow collections_flow.yml

     

       518
       518
       +
         {simple_flow_sequence: [apple, banana, cherry, date]simple_flow_mapping, {name: John, age: 30, city: New York}, nested_flow_sequences: [[a, b, c], [1, 2, 3], [red, green, blue]]nested_flow_mappings, {person: {name: Alice, age: 25}contact, {email: alice@example.com, phone: 555-1234}}, flow_seq_with_maps: [{name: Alice, role: dev}, {name: Bob, role: ops}, {name: Charlie, role: qa}]flow_map_with_seqs, {colors: [red, green, blue]sizes, [S, M, L], numbers: [1, 2, 3]}, deep_flow_nesting: {level1: {level2: {level3: {level4: [a, b, c]}}}}empty_flow, {empty_seq: []empty_map, {}, both: [[], {}]}, flow_in_block: {sequence: [1, 2, 3, 4, 5]mapping, {a: 1, b: 2, c: 3}, nested: {items: [x, y, z]config, {timeout: 30, retries: 3}}}block_in_flow, {users: [{name: Alice, tags: [dev, senior]}, {name: Bob, tags: [ops, junior]}]}, mixed_structure: {services: [{name: api, ports: [8080, 8443]env, {DEBUG: true, LOG_LEVEL: info}}, {name: db, ports: [5432]env, {POSTGRES_DB: mydb, POSTGRES_USER: admin}}]config, {version: 1, enabled: true}}flow_types, {strings: [hello, world, foo, bar]numbers, [1, 2, 3, 42, 100], mixed: [string, 123, true, false, null]quoted, [with spaces, 'special:chars', commas, here]}, flow_map_types: {string: value, number: 42, boolean: true, null_value: null, float: 3.14}nested_mixed, [{id: 1, data: [a, b, c]meta, {type: first}}, {id: 2, data: [d, e, f]meta, {type: second}}, {id: 3, data: [g, h, i]meta, {type: third}}], multiline_flow: {long_sequence: [item1, item2, item3, item4]long_mapping, {key1: value1, key2: value2, key3: value3}}edge_cases, {single_item_seq: [alone]single_item_map, {only: one}, nested_empty: [[], [{}], [{}, []]]all_empty, [{}, [], {a: []}, {b: {}}]}}

     

       519
       519
       +
       

     

       520
       520
       +
       Inline test: Simple sequence

     

       521
       521
       +
       

     

       522
       522
       +
         $ echo '- a

     

       523
       523
       +
         > - b

     

       524
       524
       +
         > - c' | yamlcat

     

       525
       525
       +
         - a

     

       526
       526
       +
         - b

     

       527
       527
       +
         - c

     

       528
       528
       +
       

     

       529
       529
       +
         $ echo '- a

     

       530
       530
       +
         > - b

     

       531
       531
       +
         > - c' | yamlcat --json

     

       532
       532
       +
         ["a", "b", "c"]

     

       533
       533
       +
       

     

       534
       534
       +
         $ echo '- a

     

       535
       535
       +
         > - b

     

       536
       536
       +
         > - c' | yamlcat --flow

     

       537
       537
       +
         [a, b, c]

     

       538
       538
       +
       

     

       539
       539
       +
       Inline test: Simple mapping

     

       540
       540
       +
       

     

       541
       541
       +
         $ echo 'key1: value1

     

       542
       542
       +
         > key2: value2

     

       543
       543
       +
         > key3: value3' | yamlcat

     

       544
       544
       +
         key1: value1

     

       545
       545
       +
         key2: value2

     

       546
       546
       +
         key3: value3

     

       547
       547
       +
       

     

       548
       548
       +
         $ echo 'key1: value1

     

       549
       549
       +
         > key2: value2

     

       550
       550
       +
         > key3: value3' | yamlcat --json

     

       551
       551
       +
         {"key1": "value1", "key2": "value2", "key3": "value3"}

     

       552
       552
       +
       

     

       553
       553
       +
         $ echo 'key1: value1

     

       554
       554
       +
         > key2: value2

     

       555
       555
       +
         > key3: value3' | yamlcat --flow

     

       556
       556
       +
         {key1: value1, key2: value2, key3: value3}

     

       557
       557
       +
       

     

       558
       558
       +
       Inline test: Nested sequences

     

       559
       559
       +
       

     

       560
       560
       +
         $ echo 'outer:

     

       561
       561
       +
         >   - - inner1

     

       562
       562
       +
         >     - inner2

     

       563
       563
       +
         >   - - inner3

     

       564
       564
       +
         >     - inner4' | yamlcat

     

       565
       565
       +
         outer:

     

       566
       566
       +
           - 

     

       567
       567
       +
             - inner1

     

       568
       568
       +
             - inner2

     

       569
       569
       +
           - 

     

       570
       570
       +
             - inner3

     

       571
       571
       +
             - inner4

     

       572
       572
       +
       

     

       573
       573
       +
         $ echo 'outer:

     

       574
       574
       +
         >   - - inner1

     

       575
       575
       +
         >     - inner2

     

       576
       576
       +
         >   - - inner3

     

       577
       577
       +
         >     - inner4' | yamlcat --json

     

       578
       578
       +
         {"outer": [["inner1", "inner2"], ["inner3", "inner4"]]}

     

       579
       579
       +
       

     

       580
       580
       +
         $ echo 'outer:

     

       581
       581
       +
         >   - - inner1

     

       582
       582
       +
         >     - inner2

     

       583
       583
       +
         >   - - inner3

     

       584
       584
       +
         >     - inner4' | yamlcat --flow

     

       585
       585
       +
         {outer: [[inner1, inner2], [inner3, inner4]]}

     

       586
       586
       +
       

     

       587
       587
       +
       Inline test: Nested mappings

     

       588
       588
       +
       

     

       589
       589
       +
         $ echo 'level1:

     

       590
       590
       +
         >   level2:

     

       591
       591
       +
         >     level3:

     

       592
       592
       +
         >       key: value' | yamlcat

     

       593
       593
       +
         level1:

     

       594
       594
       +
           level2:

     

       595
       595
       +
             level3:

     

       596
       596
       +
               key: value

     

       597
       597
       +
       

     

       598
       598
       +
         $ echo 'level1:

     

       599
       599
       +
         >   level2:

     

       600
       600
       +
         >     level3:

     

       601
       601
       +
         >       key: value' | yamlcat --json

     

       602
       602
       +
         {"level1": {"level2": {"level3": {"key": "value"}}}}

     

       603
       603
       +
       

     

       604
       604
       +
         $ echo 'level1:

     

       605
       605
       +
         >   level2:

     

       606
       606
       +
         >     level3:

     

       607
       607
       +
         >       key: value' | yamlcat --flow

     

       608
       608
       +
         {level1: {level2: {level3: {key: value}}}}

     

       609
       609
       +
       

     

       610
       610
       +
       Inline test: Flow sequence

     

       611
       611
       +
       

     

       612
       612
       +
         $ echo '[a, b, c]' | yamlcat

     

       613
       613
       +
         - a

     

       614
       614
       +
         - b

     

       615
       615
       +
         - c

     

       616
       616
       +
       

     

       617
       617
       +
         $ echo '[a, b, c]' | yamlcat --json

     

       618
       618
       +
         ["a", "b", "c"]

     

       619
       619
       +
       

     

       620
       620
       +
         $ echo '[a, b, c]' | yamlcat --flow

     

       621
       621
       +
         [a, b, c]

     

       622
       622
       +
       

     

       623
       623
       +
       Inline test: Flow mapping

     

       624
       624
       +
       

     

       625
       625
       +
         $ echo '{a: 1, b: 2, c: 3}' | yamlcat

     

       626
       626
       +
         a: 1

     

       627
       627
       +
         b: 2

     

       628
       628
       +
         c: 3

     

       629
       629
       +
       

     

       630
       630
       +
         $ echo '{a: 1, b: 2, c: 3}' | yamlcat --json

     

       631
       631
       +
         {"a": 1, "b": 2, "c": 3}

     

       632
       632
       +
       

     

       633
       633
       +
         $ echo '{a: 1, b: 2, c: 3}' | yamlcat --flow

     

       634
       634
       +
         {a: 1, b: 2, c: 3}

     

       635
       635
       +
       

     

       636
       636
       +
       Inline test: Nested flow collections

     

       637
       637
       +
       

     

       638
       638
       +
         $ echo '[[1, 2], [3, 4], [5, 6]]' | yamlcat

     

       639
       639
       +
         - 

     

       640
       640
       +
           - 1

     

       641
       641
       +
           - 2

     

       642
       642
       +
         - 

     

       643
       643
       +
           - 3

     

       644
       644
       +
           - 4

     

       645
       645
       +
         - 

     

       646
       646
       +
           - 5

     

       647
       647
       +
           - 6

     

       648
       648
       +
       

     

       649
       649
       +
         $ echo '[[1, 2], [3, 4], [5, 6]]' | yamlcat --json

     

       650
       650
       +
         [[1, 2], [3, 4], [5, 6]]

     

       651
       651
       +
       

     

       652
       652
       +
         $ echo '[[1, 2], [3, 4], [5, 6]]' | yamlcat --flow

     

       653
       653
       +
         [[1, 2], [3, 4], [5, 6]]

     

       654
       654
       +
       

     

       655
       655
       +
       Inline test: Flow mapping with nested mapping

     

       656
       656
       +
       

     

       657
       657
       +
         $ echo '{outer: {inner: value}}' | yamlcat

     

       658
       658
       +
         outer:

     

       659
       659
       +
           inner: value

     

       660
       660
       +
       

     

       661
       661
       +
         $ echo '{outer: {inner: value}}' | yamlcat --json

     

       662
       662
       +
         {"outer": {"inner": "value"}}

     

       663
       663
       +
       

     

       664
       664
       +
         $ echo '{outer: {inner: value}}' | yamlcat --flow

     

       665
       665
       +
         {outer: {inner: value}}

     

       666
       666
       +
       

     

       667
       667
       +
       Inline test: Mixed block and flow (flow in block)

     

       668
       668
       +
       

     

       669
       669
       +
         $ echo 'block_key:

     

       670
       670
       +
         >   flow_seq: [1, 2, 3]

     

       671
       671
       +
         >   flow_map: {a: 1, b: 2}' | yamlcat

     

       672
       672
       +
         block_key:

     

       673
       673
       +
           flow_seq:

     

       674
       674
       +
             - 1

     

       675
       675
       +
             - 2

     

       676
       676
       +
             - 3

     

       677
       677
       +
           flow_map:

     

       678
       678
       +
             a: 1

     

       679
       679
       +
             b: 2

     

       680
       680
       +
       

     

       681
       681
       +
         $ echo 'block_key:

     

       682
       682
       +
         >   flow_seq: [1, 2, 3]

     

       683
       683
       +
         >   flow_map: {a: 1, b: 2}' | yamlcat --json

     

       684
       684
       +
         {"block_key": {"flow_seq": [1, 2, 3], "flow_map": {"a": 1, "b": 2}}}

     

       685
       685
       +
       

     

       686
       686
       +
         $ echo 'block_key:

     

       687
       687
       +
         >   flow_seq: [1, 2, 3]

     

       688
       688
       +
         >   flow_map: {a: 1, b: 2}' | yamlcat --flow

     

       689
       689
       +
         {block_key: {flow_seq: [1, 2, 3]flow_map, {a: 1, b: 2}}}

     

       690
       690
       +
       

     

       691
       691
       +
       Inline test: Mixed block and flow (block in flow)

     

       692
       692
       +
       

     

       693
       693
       +
         $ echo '{users: [{name: Alice, age: 30}, {name: Bob, age: 25}]}' | yamlcat

     

       694
       694
       +
         users:

     

       695
       695
       +
           - name: Alice

     

       696
       696
       +
             age: 30

     

       697
       697
       +
           - name: Bob

     

       698
       698
       +
             age: 25

     

       699
       699
       +
       

     

       700
       700
       +
         $ echo '{users: [{name: Alice, age: 30}, {name: Bob, age: 25}]}' | yamlcat --json

     

       701
       701
       +
         {"users": [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]}

     

       702
       702
       +
       

     

       703
       703
       +
         $ echo '{users: [{name: Alice, age: 30}, {name: Bob, age: 25}]}' | yamlcat --flow

     

       704
       704
       +
         {users: [{name: Alice, age: 30}, {name: Bob, age: 25}]}

     

       705
       705
       +
       

     

       706
       706
       +
       Inline test: Compact notation - sequence of mappings

     

       707
       707
       +
       

     

       708
       708
       +
         $ echo '- name: Alice

     

       709
       709
       +
         >   role: dev

     

       710
       710
       +
         > - name: Bob

     

       711
       711
       +
         >   role: ops' | yamlcat

     

       712
       712
       +
         - name: Alice

     

       713
       713
       +
           role: dev

     

       714
       714
       +
         - name: Bob

     

       715
       715
       +
           role: ops

     

       716
       716
       +
       

     

       717
       717
       +
         $ echo '- name: Alice

     

       718
       718
       +
         >   role: dev

     

       719
       719
       +
         > - name: Bob

     

       720
       720
       +
         >   role: ops' | yamlcat --json

     

       721
       721
       +
         [{"name": "Alice", "role": "dev"}, {"name": "Bob", "role": "ops"}]

     

       722
       722
       +
       

     

       723
       723
       +
         $ echo '- name: Alice

     

       724
       724
       +
         >   role: dev

     

       725
       725
       +
         > - name: Bob

     

       726
       726
       +
         >   role: ops' | yamlcat --flow

     

       727
       727
       +
         [{name: Alice, role: dev}, {name: Bob, role: ops}]

     

       728
       728
       +
       

     

       729
       729
       +
       Inline test: Compact with nested collections

     

       730
       730
       +
       

     

       731
       731
       +
         $ echo '- id: 1

     

       732
       732
       +
         >   tags: [a, b, c]

     

       733
       733
       +
         >   config:

     

       734
       734
       +
         >     enabled: true

     

       735
       735
       +
         > - id: 2

     

       736
       736
       +
         >   tags: [x, y, z]

     

       737
       737
       +
         >   config:

     

       738
       738
       +
         >     enabled: false' | yamlcat

     

       739
       739
       +
         - id: 1

     

       740
       740
       +
           tags:

     

       741
       741
       +
             - a

     

       742
       742
       +
             - b

     

       743
       743
       +
             - c

     

       744
       744
       +
           config:

     

       745
       745
       +
             enabled: true

     

       746
       746
       +
         - id: 2

     

       747
       747
       +
           tags:

     

       748
       748
       +
             - x

     

       749
       749
       +
             - y

     

       750
       750
       +
             - z

     

       751
       751
       +
           config:

     

       752
       752
       +
             enabled: false

     

       753
       753
       +
       

     

       754
       754
       +
         $ echo '- id: 1

     

       755
       755
       +
         >   tags: [a, b, c]

     

       756
       756
       +
         >   config:

     

       757
       757
       +
         >     enabled: true

     

       758
       758
       +
         > - id: 2

     

       759
       759
       +
         >   tags: [x, y, z]

     

       760
       760
       +
         >   config:

     

       761
       761
       +
         >     enabled: false' | yamlcat --json

     

       762
       762
       +
         [{"id": 1, "tags": ["a", "b", "c"], "config": {"enabled": true}}, {"id": 2, "tags": ["x", "y", "z"], "config": {"enabled": false}}]

     

       763
       763
       +
       

     

       764
       764
       +
         $ echo '- id: 1

     

       765
       765
       +
         >   tags: [a, b, c]

     

       766
       766
       +
         >   config:

     

       767
       767
       +
         >     enabled: true

     

       768
       768
       +
         > - id: 2

     

       769
       769
       +
         >   tags: [x, y, z]

     

       770
       770
       +
         >   config:

     

       771
       771
       +
         >     enabled: false' | yamlcat --flow

     

       772
       772
       +
         [{id: 1, tags: [a, b, c]config, {enabled: true}}, {id: 2, tags: [x, y, z]config, {enabled: false}}]

     

       773
       773
       +
       

     

       774
       774
       +
       Inline test: Empty collections

     

       775
       775
       +
       

     

       776
       776
       +
         $ echo 'empty_seq: []

     

       777
       777
       +
         > empty_map: {}' | yamlcat

     

       778
       778
       +
         empty_seq: []

     

       779
       779
       +
         empty_map: {}

     

       780
       780
       +
       

     

       781
       781
       +
         $ echo 'empty_seq: []

     

       782
       782
       +
         > empty_map: {}' | yamlcat --json

     

       783
       783
       +
         {"empty_seq": [], "empty_map": {}}

     

       784
       784
       +
       

     

       785
       785
       +
         $ echo 'empty_seq: []

     

       786
       786
       +
         > empty_map: {}' | yamlcat --flow

     

       787
       787
       +
         {empty_seq: []empty_map, {}}

     

       788
       788
       +
       

     

       789
       789
       +
       Inline test: Sequence with mapping values

     

       790
       790
       +
       

     

       791
       791
       +
         $ echo 'items:

     

       792
       792
       +
         >   - apple

     

       793
       793
       +
         >   - banana

     

       794
       794
       +
         > config:

     

       795
       795
       +
         >   mode: fast' | yamlcat

     

       796
       796
       +
         items:

     

       797
       797
       +
           - apple

     

       798
       798
       +
           - banana

     

       799
       799
       +
         config:

     

       800
       800
       +
           mode: fast

     

       801
       801
       +
       

     

       802
       802
       +
         $ echo 'items:

     

       803
       803
       +
         >   - apple

     

       804
       804
       +
         >   - banana

     

       805
       805
       +
         > config:

     

       806
       806
       +
         >   mode: fast' | yamlcat --json

     

       807
       807
       +
         {"items": ["apple", "banana"], "config": {"mode": "fast"}}

     

       808
       808
       +
       

     

       809
       809
       +
         $ echo 'items:

     

       810
       810
       +
         >   - apple

     

       811
       811
       +
         >   - banana

     

       812
       812
       +
         > config:

     

       813
       813
       +
         >   mode: fast' | yamlcat --flow

     

       814
       814
       +
         {items: [apple, banana]config, {mode: fast}}

     

       815
       815
       +
       

     

       816
       816
       +
       Inline test: Complex nested structure

     

       817
       817
       +
       

     

       818
       818
       +
         $ echo 'services:

     

       819
       819
       +
         >   - name: web

     

       820
       820
       +
         >     ports:

     

       821
       821
       +
         >       - 80

     

       822
       822
       +
         >       - 443

     

       823
       823
       +
         >     env:

     

       824
       824
       +
         >       DEBUG: false

     

       825
       825
       +
         >       MODE: prod' | yamlcat

     

       826
       826
       +
         services:

     

       827
       827
       +
           - name: web

     

       828
       828
       +
             ports:

     

       829
       829
       +
               - 80

     

       830
       830
       +
               - 443

     

       831
       831
       +
             env:

     

       832
       832
       +
               DEBUG: false

     

       833
       833
       +
               MODE: prod

     

       834
       834
       +
       

     

       835
       835
       +
         $ echo 'services:

     

       836
       836
       +
         >   - name: web

     

       837
       837
       +
         >     ports:

     

       838
       838
       +
         >       - 80

     

       839
       839
       +
         >       - 443

     

       840
       840
       +
         >     env:

     

       841
       841
       +
         >       DEBUG: false

     

       842
       842
       +
         >       MODE: prod' | yamlcat --json

     

       843
       843
       +
         {"services": [{"name": "web", "ports": [80, 443], "env": {"DEBUG": false, "MODE": "prod"}}]}

     

       844
       844
       +
       

     

       845
       845
       +
         $ echo 'services:

     

       846
       846
       +
         >   - name: web

     

       847
       847
       +
         >     ports:

     

       848
       848
       +
         >       - 80

     

       849
       849
       +
         >       - 443

     

       850
       850
       +
         >     env:

     

       851
       851
       +
         >       DEBUG: false

     

       852
       852
       +
         >       MODE: prod' | yamlcat --flow

     

       853
       853
       +
         {services: [{name: web, ports: [80, 443]env, {DEBUG: false, MODE: prod}}]}

     

       854
       854
       +
       

     

       855
       855
       +
       Inline test: Flow sequence with various types

     

       856
       856
       +
       

     

       857
       857
       +
         $ echo '[string, 42, true, false, null, 3.14]' | yamlcat --json

     

       858
       858
       +
         ["string", 42, true, false, null, 3.14]

     

       859
       859
       +
       

     

       860
       860
       +
       Inline test: Flow mapping with various types

     

       861
       861
       +
       

     

       862
       862
       +
         $ echo '{str: hello, num: 42, bool: true, nil: null, float: 3.14}' | yamlcat --json

     

       863
       863
       +
         {"str": "hello", "num": 42, "bool": true, "nil": null, "float": 3.14}

+126

tests/cram/collections_block.yml

···

       1
       1
       +
       # Block Style Collections Test File

     

       2
       2
       +
       # Testing various block-style collection structures

     

       3
       3
       +
       

     

       4
       4
       +
       # Simple sequence

     

       5
       5
       +
       simple_sequence:

     

       6
       6
       +
         - apple

     

       7
       7
       +
         - banana

     

       8
       8
       +
         - cherry

     

       9
       9
       +
         - date

     

       10
       10
       +
       

     

       11
       11
       +
       # Simple mapping

     

       12
       12
       +
       simple_mapping:

     

       13
       13
       +
         name: John Doe

     

       14
       14
       +
         age: 30

     

       15
       15
       +
         city: New York

     

       16
       16
       +
         country: USA

     

       17
       17
       +
       

     

       18
       18
       +
       # Nested sequences

     

       19
       19
       +
       nested_sequences:

     

       20
       20
       +
         - - alpha

     

       21
       21
       +
           - beta

     

       22
       22
       +
           - gamma

     

       23
       23
       +
         - - one

     

       24
       24
       +
           - two

     

       25
       25
       +
           - three

     

       26
       26
       +
         - - red

     

       27
       27
       +
           - green

     

       28
       28
       +
           - blue

     

       29
       29
       +
       

     

       30
       30
       +
       # Nested mappings

     

       31
       31
       +
       nested_mappings:

     

       32
       32
       +
         person:

     

       33
       33
       +
           name: Alice

     

       34
       34
       +
           contact:

     

       35
       35
       +
             email: alice@example.com

     

       36
       36
       +
             phone: 555-1234

     

       37
       37
       +
           address:

     

       38
       38
       +
             street: 123 Main St

     

       39
       39
       +
             city: Boston

     

       40
       40
       +
       

     

       41
       41
       +
       # Mapping containing sequences

     

       42
       42
       +
       mapping_with_sequences:

     

       43
       43
       +
         colors:

     

       44
       44
       +
           - red

     

       45
       45
       +
           - green

     

       46
       46
       +
           - blue

     

       47
       47
       +
         sizes:

     

       48
       48
       +
           - small

     

       49
       49
       +
           - medium

     

       50
       50
       +
           - large

     

       51
       51
       +
         numbers:

     

       52
       52
       +
           - 1

     

       53
       53
       +
           - 2

     

       54
       54
       +
           - 3

     

       55
       55
       +
       

     

       56
       56
       +
       # Sequence containing mappings

     

       57
       57
       +
       sequence_with_mappings:

     

       58
       58
       +
         - name: Alice

     

       59
       59
       +
           age: 25

     

       60
       60
       +
           role: developer

     

       61
       61
       +
         - name: Bob

     

       62
       62
       +
           age: 30

     

       63
       63
       +
           role: designer

     

       64
       64
       +
         - name: Charlie

     

       65
       65
       +
           age: 35

     

       66
       66
       +
           role: manager

     

       67
       67
       +
       

     

       68
       68
       +
       # Deep nesting (4 levels)

     

       69
       69
       +
       deep_nesting:

     

       70
       70
       +
         level1:

     

       71
       71
       +
           level2:

     

       72
       72
       +
             level3:

     

       73
       73
       +
               level4:

     

       74
       74
       +
                 - deeply

     

       75
       75
       +
                 - nested

     

       76
       76
       +
                 - values

     

       77
       77
       +
               another_key: value

     

       78
       78
       +
             items:

     

       79
       79
       +
               - item1

     

       80
       80
       +
               - item2

     

       81
       81
       +
           metadata:

     

       82
       82
       +
             created: 2024-01-01

     

       83
       83
       +
             modified: 2024-12-04

     

       84
       84
       +
       

     

       85
       85
       +
       # Mixed complex structure

     

       86
       86
       +
       complex_structure:

     

       87
       87
       +
         database:

     

       88
       88
       +
           connections:

     

       89
       89
       +
             - host: db1.example.com

     

       90
       90
       +
               port: 5432

     

       91
       91
       +
               credentials:

     

       92
       92
       +
                 username: admin

     

       93
       93
       +
                 password: secret

     

       94
       94
       +
             - host: db2.example.com

     

       95
       95
       +
               port: 5432

     

       96
       96
       +
               credentials:

     

       97
       97
       +
                 username: readonly

     

       98
       98
       +
                 password: public

     

       99
       99
       +
         services:

     

       100
       100
       +
           - name: api

     

       101
       101
       +
             endpoints:

     

       102
       102
       +
               - /users

     

       103
       103
       +
               - /posts

     

       104
       104
       +
               - /comments

     

       105
       105
       +
             config:

     

       106
       106
       +
               timeout: 30

     

       107
       107
       +
               retries: 3

     

       108
       108
       +
           - name: worker

     

       109
       109
       +
             tasks:

     

       110
       110
       +
               - email

     

       111
       111
       +
               - reports

     

       112
       112
       +
             config:

     

       113
       113
       +
               concurrency: 10

     

       114
       114
       +
       

     

       115
       115
       +
       # Empty sequences and mappings in block style

     

       116
       116
       +
       empty_collections:

     

       117
       117
       +
         empty_sequence: []

     

       118
       118
       +
         empty_mapping: {}

     

       119
       119
       +
         sequence_with_empty:

     

       120
       120
       +
           - value1

     

       121
       121
       +
           - []

     

       122
       122
       +
           - value2

     

       123
       123
       +
         mapping_with_empty:

     

       124
       124
       +
           key1: value1

     

       125
       125
       +
           key2: {}

     

       126
       126
       +
           key3: value3

+198

tests/cram/collections_compact.yml

···

       1
       1
       +
       # Compact Notation Collections Test File

     

       2
       2
       +
       # Testing compact block notation and mixed styles

     

       3
       3
       +
       

     

       4
       4
       +
       # Compact nested mapping in sequence (most common form)

     

       5
       5
       +
       compact_sequence:

     

       6
       6
       +
         - name: Alice

     

       7
       7
       +
           age: 25

     

       8
       8
       +
           city: Boston

     

       9
       9
       +
         - name: Bob

     

       10
       10
       +
           age: 30

     

       11
       11
       +
           city: Seattle

     

       12
       12
       +
         - name: Charlie

     

       13
       13
       +
           age: 35

     

       14
       14
       +
           city: Portland

     

       15
       15
       +
       

     

       16
       16
       +
       # Compact with nested structures

     

       17
       17
       +
       compact_nested:

     

       18
       18
       +
         - id: 1

     

       19
       19
       +
           details:

     

       20
       20
       +
             type: admin

     

       21
       21
       +
             permissions:

     

       22
       22
       +
               - read

     

       23
       23
       +
               - write

     

       24
       24
       +
               - delete

     

       25
       25
       +
         - id: 2

     

       26
       26
       +
           details:

     

       27
       27
       +
             type: user

     

       28
       28
       +
             permissions:

     

       29
       29
       +
               - read

     

       30
       30
       +
       

     

       31
       31
       +
       # Multiple keys in same sequence entry with sub-structures

     

       32
       32
       +
       compact_complex:

     

       33
       33
       +
         - key1: value1

     

       34
       34
       +
           key2: value2

     

       35
       35
       +
           nested:

     

       36
       36
       +
             sub1: val1

     

       37
       37
       +
             sub2: val2

     

       38
       38
       +
         - key1: value3

     

       39
       39
       +
           key2: value4

     

       40
       40
       +
           nested:

     

       41
       41
       +
             sub1: val3

     

       42
       42
       +
             sub2: val4

     

       43
       43
       +
       

     

       44
       44
       +
       # Compact block mappings with inline values

     

       45
       45
       +
       users:

     

       46
       46
       +
         - username: alice

     

       47
       47
       +
           email: alice@example.com

     

       48
       48
       +
           active: true

     

       49
       49
       +
         - username: bob

     

       50
       50
       +
           email: bob@example.com

     

       51
       51
       +
           active: false

     

       52
       52
       +
       

     

       53
       53
       +
       # Compact with flow collections

     

       54
       54
       +
       compact_with_flow:

     

       55
       55
       +
         - name: service1

     

       56
       56
       +
           ports: [8080, 8443]

     

       57
       57
       +
           env: {DEBUG: true, MODE: production}

     

       58
       58
       +
         - name: service2

     

       59
       59
       +
           ports: [3000]

     

       60
       60
       +
           env: {DEBUG: false, MODE: development}

     

       61
       61
       +
       

     

       62
       62
       +
       # Deeply nested compact notation

     

       63
       63
       +
       deep_compact:

     

       64
       64
       +
         - category: electronics

     

       65
       65
       +
           items:

     

       66
       66
       +
             - name: laptop

     

       67
       67
       +
               specs:

     

       68
       68
       +
                 cpu: Intel i7

     

       69
       69
       +
                 ram: 16GB

     

       70
       70
       +
                 storage: 512GB SSD

     

       71
       71
       +
             - name: phone

     

       72
       72
       +
               specs:

     

       73
       73
       +
                 os: Android

     

       74
       74
       +
                 ram: 8GB

     

       75
       75
       +
                 storage: 256GB

     

       76
       76
       +
         - category: furniture

     

       77
       77
       +
           items:

     

       78
       78
       +
             - name: desk

     

       79
       79
       +
               dimensions:

     

       80
       80
       +
                 width: 150cm

     

       81
       81
       +
                 depth: 75cm

     

       82
       82
       +
                 height: 75cm

     

       83
       83
       +
             - name: chair

     

       84
       84
       +
               dimensions:

     

       85
       85
       +
                 width: 60cm

     

       86
       86
       +
                 depth: 60cm

     

       87
       87
       +
                 height: 120cm

     

       88
       88
       +
       

     

       89
       89
       +
       # Compact with mixed indentation styles

     

       90
       90
       +
       mixed_compact:

     

       91
       91
       +
         databases:

     

       92
       92
       +
           - type: postgresql

     

       93
       93
       +
             connection:

     

       94
       94
       +
               host: localhost

     

       95
       95
       +
               port: 5432

     

       96
       96
       +
             credentials:

     

       97
       97
       +
               user: admin

     

       98
       98
       +
               password: secret

     

       99
       99
       +
           - type: mongodb

     

       100
       100
       +
             connection:

     

       101
       101
       +
               host: localhost

     

       102
       102
       +
               port: 27017

     

       103
       103
       +
             credentials:

     

       104
       104
       +
               user: root

     

       105
       105
       +
               password: root

     

       106
       106
       +
       

     

       107
       107
       +
       # Single-line compact entries

     

       108
       108
       +
       single_line_compact:

     

       109
       109
       +
         - {name: Alice, age: 25, role: developer}

     

       110
       110
       +
         - {name: Bob, age: 30, role: designer}

     

       111
       111
       +
         - {name: Charlie, age: 35, role: manager}

     

       112
       112
       +
       

     

       113
       113
       +
       # Compact notation with sequences as values

     

       114
       114
       +
       sequences_in_compact:

     

       115
       115
       +
         - title: Project A

     

       116
       116
       +
           members:

     

       117
       117
       +
             - Alice

     

       118
       118
       +
             - Bob

     

       119
       119
       +
             - Charlie

     

       120
       120
       +
           tags:

     

       121
       121
       +
             - urgent

     

       122
       122
       +
             - backend

     

       123
       123
       +
         - title: Project B

     

       124
       124
       +
           members:

     

       125
       125
       +
             - David

     

       126
       126
       +
             - Eve

     

       127
       127
       +
           tags:

     

       128
       128
       +
             - frontend

     

       129
       129
       +
             - design

     

       130
       130
       +
       

     

       131
       131
       +
       # Compact with empty values

     

       132
       132
       +
       compact_with_empty:

     

       133
       133
       +
         - id: 1

     

       134
       134
       +
           data: []

     

       135
       135
       +
           meta: {}

     

       136
       136
       +
         - id: 2

     

       137
       137
       +
           data:

     

       138
       138
       +
             - item1

     

       139
       139
       +
           meta:

     

       140
       140
       +
             key: value

     

       141
       141
       +
       

     

       142
       142
       +
       # Compact notation with complex nesting

     

       143
       143
       +
       compact_complex_nesting:

     

       144
       144
       +
         - level: 1

     

       145
       145
       +
           children:

     

       146
       146
       +
             - level: 2a

     

       147
       147
       +
               children:

     

       148
       148
       +
                 - level: 3a

     

       149
       149
       +
                   value: leaf1

     

       150
       150
       +
                 - level: 3b

     

       151
       151
       +
                   value: leaf2

     

       152
       152
       +
             - level: 2b

     

       153
       153
       +
               children:

     

       154
       154
       +
                 - level: 3c

     

       155
       155
       +
                   value: leaf3

     

       156
       156
       +
       

     

       157
       157
       +
       # Real-world example: API endpoints

     

       158
       158
       +
       api_endpoints:

     

       159
       159
       +
         - path: /users

     

       160
       160
       +
           method: GET

     

       161
       161
       +
           auth: required

     

       162
       162
       +
           params:

     

       163
       163
       +
             - name: page

     

       164
       164
       +
               type: integer

     

       165
       165
       +
               default: 1

     

       166
       166
       +
             - name: limit

     

       167
       167
       +
               type: integer

     

       168
       168
       +
               default: 10

     

       169
       169
       +
         - path: /users/:id

     

       170
       170
       +
           method: GET

     

       171
       171
       +
           auth: required

     

       172
       172
       +
           params: []

     

       173
       173
       +
         - path: /users

     

       174
       174
       +
           method: POST

     

       175
       175
       +
           auth: required

     

       176
       176
       +
           body:

     

       177
       177
       +
             username: string

     

       178
       178
       +
             email: string

     

       179
       179
       +
             password: string

     

       180
       180
       +
       

     

       181
       181
       +
       # Compact with various data types

     

       182
       182
       +
       compact_types:

     

       183
       183
       +
         - string_val: hello

     

       184
       184
       +
           number_val: 42

     

       185
       185
       +
           float_val: 3.14

     

       186
       186
       +
           bool_val: true

     

       187
       187
       +
           null_val: null

     

       188
       188
       +
         - string_val: world

     

       189
       189
       +
           number_val: 100

     

       190
       190
       +
           float_val: 2.71

     

       191
       191
       +
           bool_val: false

     

       192
       192
       +
           null_val: ~

     

       193
       193
       +
       

     

       194
       194
       +
       # Edge case: minimal compact notation

     

       195
       195
       +
       minimal:

     

       196
       196
       +
         - a: 1

     

       197
       197
       +
         - b: 2

     

       198
       198
       +
         - c: 3

+96

tests/cram/collections_flow.yml

···

       1
       1
       +
       # Flow Style Collections Test File

     

       2
       2
       +
       # Testing various flow-style collection structures

     

       3
       3
       +
       

     

       4
       4
       +
       # Simple flow sequence

     

       5
       5
       +
       simple_flow_sequence: [apple, banana, cherry, date]

     

       6
       6
       +
       

     

       7
       7
       +
       # Simple flow mapping

     

       8
       8
       +
       simple_flow_mapping: {name: John, age: 30, city: New York}

     

       9
       9
       +
       

     

       10
       10
       +
       # Nested flow sequences

     

       11
       11
       +
       nested_flow_sequences: [[a, b, c], [1, 2, 3], [red, green, blue]]

     

       12
       12
       +
       

     

       13
       13
       +
       # Nested flow mappings

     

       14
       14
       +
       nested_flow_mappings: {person: {name: Alice, age: 25}, contact: {email: alice@example.com, phone: 555-1234}}

     

       15
       15
       +
       

     

       16
       16
       +
       # Flow sequence with mappings

     

       17
       17
       +
       flow_seq_with_maps: [{name: Alice, role: dev}, {name: Bob, role: ops}, {name: Charlie, role: qa}]

     

       18
       18
       +
       

     

       19
       19
       +
       # Flow mapping with sequences

     

       20
       20
       +
       flow_map_with_seqs: {colors: [red, green, blue], sizes: [S, M, L], numbers: [1, 2, 3]}

     

       21
       21
       +
       

     

       22
       22
       +
       # Deeply nested flow collections

     

       23
       23
       +
       deep_flow_nesting: {level1: {level2: {level3: {level4: [a, b, c]}}}}

     

       24
       24
       +
       

     

       25
       25
       +
       # Empty flow collections

     

       26
       26
       +
       empty_flow: {empty_seq: [], empty_map: {}, both: [[], {}]}

     

       27
       27
       +
       

     

       28
       28
       +
       # Mixed flow and block - flow in block

     

       29
       29
       +
       flow_in_block:

     

       30
       30
       +
         sequence: [1, 2, 3, 4, 5]

     

       31
       31
       +
         mapping: {a: 1, b: 2, c: 3}

     

       32
       32
       +
         nested:

     

       33
       33
       +
           items: [x, y, z]

     

       34
       34
       +
           config: {timeout: 30, retries: 3}

     

       35
       35
       +
       

     

       36
       36
       +
       # Mixed flow and block - block in flow

     

       37
       37
       +
       block_in_flow: {

     

       38
       38
       +
         users: [

     

       39
       39
       +
           {name: Alice, tags: [dev, senior]},

     

       40
       40
       +
           {name: Bob, tags: [ops, junior]}

     

       41
       41
       +
         ]

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       # Complex mixed structure

     

       45
       45
       +
       mixed_structure:

     

       46
       46
       +
         services:

     

       47
       47
       +
           - name: api

     

       48
       48
       +
             ports: [8080, 8443]

     

       49
       49
       +
             env: {DEBUG: true, LOG_LEVEL: info}

     

       50
       50
       +
           - name: db

     

       51
       51
       +
             ports: [5432]

     

       52
       52
       +
             env: {POSTGRES_DB: mydb, POSTGRES_USER: admin}

     

       53
       53
       +
         config: {version: 1.0, enabled: true}

     

       54
       54
       +
       

     

       55
       55
       +
       # Flow sequences with various types

     

       56
       56
       +
       flow_types:

     

       57
       57
       +
         strings: [hello, world, foo, bar]

     

       58
       58
       +
         numbers: [1, 2, 3, 42, 100]

     

       59
       59
       +
         mixed: [string, 123, true, false, null]

     

       60
       60
       +
         quoted: ["with spaces", "special:chars", "commas, here"]

     

       61
       61
       +
       

     

       62
       62
       +
       # Flow mappings with various types

     

       63
       63
       +
       flow_map_types: {

     

       64
       64
       +
         string: value,

     

       65
       65
       +
         number: 42,

     

       66
       66
       +
         boolean: true,

     

       67
       67
       +
         null_value: null,

     

       68
       68
       +
         float: 3.14

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       # Nested mixed collections

     

       72
       72
       +
       nested_mixed:

     

       73
       73
       +
         - {id: 1, data: [a, b, c], meta: {type: first}}

     

       74
       74
       +
         - {id: 2, data: [d, e, f], meta: {type: second}}

     

       75
       75
       +
         - {id: 3, data: [g, h, i], meta: {type: third}}

     

       76
       76
       +
       

     

       77
       77
       +
       # Flow with multiline (should still be valid)

     

       78
       78
       +
       multiline_flow:

     

       79
       79
       +
         long_sequence: [

     

       80
       80
       +
           item1,

     

       81
       81
       +
           item2,

     

       82
       82
       +
           item3,

     

       83
       83
       +
           item4

     

       84
       84
       +
         ]

     

       85
       85
       +
         long_mapping: {

     

       86
       86
       +
           key1: value1,

     

       87
       87
       +
           key2: value2,

     

       88
       88
       +
           key3: value3

     

       89
       89
       +
         }

     

       90
       90
       +
       

     

       91
       91
       +
       # Edge cases

     

       92
       92
       +
       edge_cases:

     

       93
       93
       +
         single_item_seq: [alone]

     

       94
       94
       +
         single_item_map: {only: one}

     

       95
       95
       +
         nested_empty: [[], [{}], [{}, []]]

     

       96
       96
       +
         all_empty: [{}, [], {a: []}, {b: {}}]

+197

tests/cram/comments.t

···

       1
       1
       +
       Test comments.yml file with various comment styles

     

       2
       2
       +
       

     

       3
       3
       +
         $ yamlcat comments.yml

     

       4
       4
       +
         name: John Doe

     

       5
       5
       +
         age: 30

     

       6
       6
       +
         address:

     

       7
       7
       +
           street: 123 Main St

     

       8
       8
       +
           city: Springfield

     

       9
       9
       +
           zip: 12345

     

       10
       10
       +
         items:

     

       11
       11
       +
           - apple

     

       12
       12
       +
           - banana

     

       13
       13
       +
           - cherry

     

       14
       14
       +
           - date

     

       15
       15
       +
         flow_seq:

     

       16
       16
       +
           - 1

     

       17
       17
       +
           - 2

     

       18
       18
       +
           - 3

     

       19
       19
       +
         flow_map:

     

       20
       20
       +
           key1: value1

     

       21
       21
       +
           key2: value2

     

       22
       22
       +
         nested:

     

       23
       23
       +
           level1:

     

       24
       24
       +
             level2:

     

       25
       25
       +
               value: deeply nested

     

       26
       26
       +
         multi_comment_key: value

     

       27
       27
       +
         special: 'value with # hash inside quotes'

     

       28
       28
       +
         empty_value: null

     

       29
       29
       +
         final_key: final_value

     

       30
       30
       +
       

     

       31
       31
       +
       Test comments.yml roundtrip with JSON to verify parsed values

     

       32
       32
       +
       

     

       33
       33
       +
         $ yamlcat --json comments.yml

     

       34
       34
       +
         {"name": "John Doe", "age": 30, "address": {"street": "123 Main St", "city": "Springfield", "zip": 12345}, "items": ["apple", "banana", "cherry", "date"], "flow_seq": [1, 2, 3], "flow_map": {"key1": "value1", "key2": "value2"}, "nested": {"level1": {"level2": {"value": "deeply nested"}}}, "multi_comment_key": "value", "special": "value with # hash inside quotes", "empty_value": null, "final_key": "final_value"}

     

       35
       35
       +
       

     

       36
       36
       +
       Test full line comments are ignored

     

       37
       37
       +
       

     

       38
       38
       +
         $ echo '# This is a full line comment

     

       39
       39
       +
         > name: Alice

     

       40
       40
       +
         > # Another comment

     

       41
       41
       +
         > age: 25' | yamlcat --json

     

       42
       42
       +
         {"name": "Alice", "age": 25}

     

       43
       43
       +
       

     

       44
       44
       +
       Test end of line comments after scalars

     

       45
       45
       +
       

     

       46
       46
       +
         $ echo 'name: Bob  # This is an end of line comment

     

       47
       47
       +
         > age: 35  # Another end of line comment' | yamlcat --json

     

       48
       48
       +
         {"name": "Bob", "age": 35}

     

       49
       49
       +
       

     

       50
       50
       +
       Test comments after sequence items

     

       51
       51
       +
       

     

       52
       52
       +
         $ echo 'fruits:

     

       53
       53
       +
         >   - apple  # First fruit

     

       54
       54
       +
         >   - banana  # Second fruit

     

       55
       55
       +
         >   - cherry  # Third fruit' | yamlcat --json

     

       56
       56
       +
         {"fruits": ["apple", "banana", "cherry"]}

     

       57
       57
       +
       

     

       58
       58
       +
       Test comments between sequence items

     

       59
       59
       +
       

     

       60
       60
       +
         $ echo 'numbers:

     

       61
       61
       +
         >   - 1

     

       62
       62
       +
         >   # Comment between items

     

       63
       63
       +
         >   - 2

     

       64
       64
       +
         >   # Another comment

     

       65
       65
       +
         >   - 3' | yamlcat --json

     

       66
       66
       +
         {"numbers": [1, 2, 3]}

     

       67
       67
       +
       

     

       68
       68
       +
       Test comments after flow sequences

     

       69
       69
       +
       

     

       70
       70
       +
         $ echo 'flow: [1, 2, 3]  # Comment after flow sequence' | yamlcat --json

     

       71
       71
       +
         {"flow": [1, 2, 3]}

     

       72
       72
       +
       

     

       73
       73
       +
       Test comments after flow mappings

     

       74
       74
       +
       

     

       75
       75
       +
         $ echo 'flow: {a: 1, b: 2}  # Comment after flow mapping' | yamlcat --json

     

       76
       76
       +
         {"flow": {"a": 1, "b": 2}}

     

       77
       77
       +
       

     

       78
       78
       +
       Test comments between mapping entries

     

       79
       79
       +
       

     

       80
       80
       +
         $ echo 'first: value1

     

       81
       81
       +
         > # Comment between entries

     

       82
       82
       +
         > second: value2

     

       83
       83
       +
         > # Another comment

     

       84
       84
       +
         > third: value3' | yamlcat --json

     

       85
       85
       +
         {"first": "value1", "second": "value2", "third": "value3"}

     

       86
       86
       +
       

     

       87
       87
       +
       Test multiple consecutive comments

     

       88
       88
       +
       

     

       89
       89
       +
         $ echo '# First comment

     

       90
       90
       +
         > # Second comment

     

       91
       91
       +
         > # Third comment

     

       92
       92
       +
         > key: value' | yamlcat --json

     

       93
       93
       +
         {"key": "value"}

     

       94
       94
       +
       

     

       95
       95
       +
       Test comments in nested structures

     

       96
       96
       +
       

     

       97
       97
       +
         $ echo 'outer:

     

       98
       98
       +
         >   # Comment in nested level

     

       99
       99
       +
         >   inner:

     

       100
       100
       +
         >     # Comment in deeper level

     

       101
       101
       +
         >     key: value  # End of line comment' | yamlcat --json

     

       102
       102
       +
         {"outer": {"inner": {"key": "value"}}}

     

       103
       103
       +
       

     

       104
       104
       +
       Test comments with special characters

     

       105
       105
       +
       

     

       106
       106
       +
         $ echo '# Comment with !@#$%^&*()

     

       107
       107
       +
         > key: value' | yamlcat --json

     

       108
       108
       +
         {"key": "value"}

     

       109
       109
       +
       

     

       110
       110
       +
       Test that hash in quoted strings is not treated as comment

     

       111
       111
       +
       

     

       112
       112
       +
         $ echo 'text: "This # is not a comment"

     

       113
       113
       +
         > other: '"'"'Also # not a comment'"'"'' | yamlcat --json

     

       114
       114
       +
         {"text": "This # is not a comment", "other": "Also # not a comment"}

     

       115
       115
       +
       

     

       116
       116
       +
       Test comment before empty value (null)

     

       117
       117
       +
       

     

       118
       118
       +
         $ echo 'key:  # Comment, value is null' | yamlcat --json

     

       119
       119
       +
         {"key": null}

     

       120
       120
       +
       

     

       121
       121
       +
       Test comments at document start

     

       122
       122
       +
       

     

       123
       123
       +
         $ echo '# Comment at very start

     

       124
       124
       +
         > # Another at start

     

       125
       125
       +
         > data: value' | yamlcat --json

     

       126
       126
       +
         {"data": "value"}

     

       127
       127
       +
       

     

       128
       128
       +
       Test comments at document end

     

       129
       129
       +
       

     

       130
       130
       +
         $ echo 'data: value

     

       131
       131
       +
         > # Comment at end

     

       132
       132
       +
         > # Another at end' | yamlcat --json

     

       133
       133
       +
         {"data": "value"}

     

       134
       134
       +
       

     

       135
       135
       +
       Test comments with various indentation levels

     

       136
       136
       +
       

     

       137
       137
       +
         $ echo 'level1:

     

       138
       138
       +
         >     # Indented comment

     

       139
       139
       +
         >     level2:

     

       140
       140
       +
         >         # More indented comment

     

       141
       141
       +
         >         value: data' | yamlcat --json

     

       142
       142
       +
         {"level1": {"level2": {"value": "data"}}}

     

       143
       143
       +
       

     

       144
       144
       +
       Test empty lines with comments

     

       145
       145
       +
       

     

       146
       146
       +
         $ echo 'first: 1

     

       147
       147
       +
         > 

     

       148
       148
       +
         > # Comment after empty line

     

       149
       149
       +
         > 

     

       150
       150
       +
         > second: 2' | yamlcat --json

     

       151
       151
       +
         {"first": 1, "second": 2}

     

       152
       152
       +
       

     

       153
       153
       +
       Test comment after sequence with nested mapping

     

       154
       154
       +
       

     

       155
       155
       +
         $ echo 'items:

     

       156
       156
       +
         >   - name: item1  # Comment after nested value

     

       157
       157
       +
         >     value: 10

     

       158
       158
       +
         >   # Comment between sequence items

     

       159
       159
       +
         >   - name: item2

     

       160
       160
       +
         >     value: 20  # Another comment' | yamlcat --json

     

       161
       161
       +
         {"items": [{"name": "item1", "value": 10}, {"name": "item2", "value": 20}]}

     

       162
       162
       +
       

     

       163
       163
       +
       Test comment only lines between complex structures

     

       164
       164
       +
       

     

       165
       165
       +
         $ echo 'mapping1:

     

       166
       166
       +
         >   key: value

     

       167
       167
       +
         > # Comment between mappings

     

       168
       168
       +
         > mapping2:

     

       169
       169
       +
         >   key: value' | yamlcat --json

     

       170
       170
       +
         {"mapping1": {"key": "value"}, "mapping2": {"key": "value"}}

     

       171
       171
       +
       

     

       172
       172
       +
       Test comments do not affect block scalars

     

       173
       173
       +
       

     

       174
       174
       +
         $ echo 'literal: |

     

       175
       175
       +
         >   # This looks like a comment

     

       176
       176
       +
         >   but it is part of the literal text

     

       177
       177
       +
         > key: value' | yamlcat --json

     

       178
       178
       +
         {"literal": "# This looks like a comment\nbut it is part of the literal text\n", "key": "value"}

     

       179
       179
       +
       

     

       180
       180
       +
       Test comments do not affect folded scalars

     

       181
       181
       +
       

     

       182
       182
       +
         $ echo 'folded: >

     

       183
       183
       +
         >   # This also looks like a comment

     

       184
       184
       +
         >   but is part of folded text

     

       185
       185
       +
         > key: value' | yamlcat --json

     

       186
       186
       +
         {"folded": "# This also looks like a comment but is part of folded text\n", "key": "value"}

     

       187
       187
       +
       

     

       188
       188
       +
       Test whitespace preservation around comments

     

       189
       189
       +
       

     

       190
       190
       +
         $ echo 'key1:    value1   # Comment with spaces' | yamlcat --json

     

       191
       191
       +
         {"key1": "value1"}

     

       192
       192
       +
       

     

       193
       193
       +
       Test comment after colon but before value

     

       194
       194
       +
       

     

       195
       195
       +
         $ echo 'key: # Comment before value

     

       196
       196
       +
         >   value' | yamlcat --json

     

       197
       197
       +
         {"key": "value"}

+53

tests/cram/comments.yml

···

       1
       1
       +
       # Full line comment at the beginning

     

       2
       2
       +
       # This is a YAML file testing comment handling

     

       3
       3
       +
       

     

       4
       4
       +
       # Comment before a mapping

     

       5
       5
       +
       name: John Doe  # End of line comment after a scalar value

     

       6
       6
       +
       age: 30  # Another end of line comment

     

       7
       7
       +
       

     

       8
       8
       +
       # Comment between mapping entries

     

       9
       9
       +
       address:

     

       10
       10
       +
         # Comment inside nested mapping

     

       11
       11
       +
         street: 123 Main St  # End of line comment in nested value

     

       12
       12
       +
         city: Springfield

     

       13
       13
       +
         # Comment between nested entries

     

       14
       14
       +
         zip: 12345

     

       15
       15
       +
       

     

       16
       16
       +
       # Comment before sequence

     

       17
       17
       +
       items:

     

       18
       18
       +
         - apple  # Comment after sequence item

     

       19
       19
       +
         - banana

     

       20
       20
       +
         # Comment between sequence items

     

       21
       21
       +
         - cherry

     

       22
       22
       +
         - date  # Last item comment

     

       23
       23
       +
       

     

       24
       24
       +
       # Comment before flow sequence

     

       25
       25
       +
       flow_seq: [1, 2, 3]  # Comment after flow sequence

     

       26
       26
       +
       

     

       27
       27
       +
       # Comment before flow mapping

     

       28
       28
       +
       flow_map: {key1: value1, key2: value2}  # Comment after flow mapping

     

       29
       29
       +
       

     

       30
       30
       +
       # Comments with various indentation levels

     

       31
       31
       +
       nested:

     

       32
       32
       +
           # Indented comment level 1

     

       33
       33
       +
           level1:

     

       34
       34
       +
               # Indented comment level 2

     

       35
       35
       +
               level2:

     

       36
       36
       +
                   # Indented comment level 3

     

       37
       37
       +
                   value: deeply nested  # End comment at depth

     

       38
       38
       +
       

     

       39
       39
       +
       # Multiple consecutive comments

     

       40
       40
       +
       # Line 1

     

       41
       41
       +
       # Line 2

     

       42
       42
       +
       # Line 3

     

       43
       43
       +
       multi_comment_key: value

     

       44
       44
       +
       

     

       45
       45
       +
       # Comment with special characters: !@#$%^&*()

     

       46
       46
       +
       special: "value with # hash inside quotes"

     

       47
       47
       +
       

     

       48
       48
       +
       # Empty value with comment

     

       49
       49
       +
       empty_value:  # This key has no value (null)

     

       50
       50
       +
       

     

       51
       51
       +
       # Comment before document end

     

       52
       52
       +
       final_key: final_value

     

       53
       53
       +
       # Final comment at end of file

tests/cram/depth_bomb.yml

···

       1
       1
       +
       a: &a [x, y, z]

     

       2
       2
       +
       b: &b [*a, *a]

     

       3
       3
       +
       c: &c [*b, *b]

     

       4
       4
       +
       d: &d [*c, *c]

     

       5
       5
       +
       e: &e [*d, *d]

     

       6
       6
       +
       result: *e

tests/cram/directives.yml

···

       1
       1
       +
       # YAML directive tests

     

       2
       2
       +
       

     

       3
       3
       +
       # Test 1: %YAML 1.2 directive

     

       4
       4
       +
       %YAML 1.2

     

       5
       5
       +
       ---

     

       6
       6
       +
       version: "1.2"

     

       7
       7
       +
       content: This document uses YAML 1.2

     

       8
       8
       +
       ...

+15

tests/cram/directives_multiple_tags.yml

···

       1
       1
       +
       # Test 4: Multiple TAG directives

     

       2
       2
       +
       %YAML 1.2

     

       3
       3
       +
       %TAG !e! tag:example.com,2025:

     

       4
       4
       +
       %TAG !app! tag:myapp.org,2025:types:

     

       5
       5
       +
       %TAG !geo! tag:geography.net,2025:shapes:

     

       6
       6
       +
       ---

     

       7
       7
       +
       user: !e!person

     

       8
       8
       +
         name: Alice

     

       9
       9
       +
         age: 30

     

       10
       10
       +
       location: !geo!coordinates

     

       11
       11
       +
         lat: 40.7128

     

       12
       12
       +
         lon: -74.0060

     

       13
       13
       +
       config: !app!settings

     

       14
       14
       +
         debug: true

     

       15
       15
       +
         timeout: 30

+10

tests/cram/directives_tag.yml

···

       1
       1
       +
       # Test 3: %TAG directive with custom prefix

     

       2
       2
       +
       %YAML 1.2

     

       3
       3
       +
       %TAG !custom! tag:example.com,2025:

     

       4
       4
       +
       ---

     

       5
       5
       +
       shape: !custom!circle

     

       6
       6
       +
         radius: 5

     

       7
       7
       +
         color: red

     

       8
       8
       +
       point: !custom!point

     

       9
       9
       +
         x: 10

     

       10
       10
       +
         y: 20

+10

tests/cram/directives_yaml11.yml

···

       1
       1
       +
       # Test 2: %YAML 1.1 directive

     

       2
       2
       +
       %YAML 1.1

     

       3
       3
       +
       ---

     

       4
       4
       +
       version: "1.1"

     

       5
       5
       +
       content: This document uses YAML 1.1

     

       6
       6
       +
       booleans:

     

       7
       7
       +
         - yes

     

       8
       8
       +
         - no

     

       9
       9
       +
         - on

     

       10
       10
       +
         - off

+204

tests/cram/documents.t

···

       1
       1
       +
       Test YAML directives and single document parsing

     

       2
       2
       +
       

     

       3
       3
       +
       This test suite covers YAML directives (%YAML, %TAG) and various single document formats.

     

       4
       4
       +
       Multi-document streams are not yet supported and are not tested here.

     

       5
       5
       +
       

     

       6
       6
       +
       Test 1: Basic YAML 1.2 directive

     

       7
       7
       +
       ====================================

     

       8
       8
       +
       

     

       9
       9
       +
         $ yamlcat directives.yml

     

       10
       10
       +
         version: '1.2'

     

       11
       11
       +
         content: This document uses YAML 1.2

     

       12
       12
       +
       

     

       13
       13
       +
       Test 2: YAML 1.1 directive

     

       14
       14
       +
       ====================================

     

       15
       15
       +
       

     

       16
       16
       +
         $ yamlcat directives_yaml11.yml

     

       17
       17
       +
         version: '1.1'

     

       18
       18
       +
         content: This document uses YAML 1.1

     

       19
       19
       +
         booleans:

     

       20
       20
       +
           - true

     

       21
       21
       +
           - false

     

       22
       22
       +
           - true

     

       23
       23
       +
           - false

     

       24
       24
       +
       

     

       25
       25
       +
       Test 3: TAG directive with custom prefix

     

       26
       26
       +
       ====================================

     

       27
       27
       +
       

     

       28
       28
       +
         $ yamlcat directives_tag.yml

     

       29
       29
       +
         shape:

     

       30
       30
       +
           radius: 5

     

       31
       31
       +
           color: red

     

       32
       32
       +
         point:

     

       33
       33
       +
           x: 10

     

       34
       34
       +
           y: 20

     

       35
       35
       +
       

     

       36
       36
       +
       Test 4: Multiple TAG directives

     

       37
       37
       +
       ====================================

     

       38
       38
       +
       

     

       39
       39
       +
         $ yamlcat directives_multiple_tags.yml

     

       40
       40
       +
         user:

     

       41
       41
       +
           name: Alice

     

       42
       42
       +
           age: 30

     

       43
       43
       +
         location:

     

       44
       44
       +
           lat: 40.7128

     

       45
       45
       +
           lon: -74.006

     

       46
       46
       +
         config:

     

       47
       47
       +
           debug: true

     

       48
       48
       +
           timeout: 30

     

       49
       49
       +
       

     

       50
       50
       +
       Test 5: Implicit document (no markers)

     

       51
       51
       +
       ====================================

     

       52
       52
       +
       

     

       53
       53
       +
         $ yamlcat documents_single.yml

     

       54
       54
       +
         key1: value1

     

       55
       55
       +
         key2: value2

     

       56
       56
       +
         nested:

     

       57
       57
       +
           inner: data

     

       58
       58
       +
         list:

     

       59
       59
       +
           - item1

     

       60
       60
       +
           - item2

     

       61
       61
       +
           - item3

     

       62
       62
       +
       

     

       63
       63
       +
       Test 6: Explicit start marker (---)

     

       64
       64
       +
       ====================================

     

       65
       65
       +
       

     

       66
       66
       +
         $ yamlcat documents_single_explicit_start.yml

     

       67
       67
       +
         key1: value1

     

       68
       68
       +
         key2: value2

     

       69
       69
       +
         nested:

     

       70
       70
       +
           inner: data

     

       71
       71
       +
         list:

     

       72
       72
       +
           - item1

     

       73
       73
       +
           - item2

     

       74
       74
       +
           - item3

     

       75
       75
       +
       

     

       76
       76
       +
       Test 7: Explicit start and end markers (--- ... )

     

       77
       77
       +
       ====================================

     

       78
       78
       +
       

     

       79
       79
       +
         $ yamlcat documents_single_explicit_both.yml

     

       80
       80
       +
         key1: value1

     

       81
       81
       +
         key2: value2

     

       82
       82
       +
         nested:

     

       83
       83
       +
           inner: data

     

       84
       84
       +
         list:

     

       85
       85
       +
           - item1

     

       86
       86
       +
           - item2

     

       87
       87
       +
           - item3

     

       88
       88
       +
       

     

       89
       89
       +
       Test 8: Document with YAML directive

     

       90
       90
       +
       ====================================

     

       91
       91
       +
       

     

       92
       92
       +
         $ yamlcat documents_single_with_directive.yml

     

       93
       93
       +
         key1: value1

     

       94
       94
       +
         key2: value2

     

       95
       95
       +
         nested:

     

       96
       96
       +
           inner: data

     

       97
       97
       +
         list:

     

       98
       98
       +
           - item1

     

       99
       99
       +
           - item2

     

       100
       100
       +
           - item3

     

       101
       101
       +
       

     

       102
       102
       +
       Test 9: Inline - implicit document (no markers)

     

       103
       103
       +
       ====================================

     

       104
       104
       +
       

     

       105
       105
       +
         $ echo 'name: John

     

       106
       106
       +
         > age: 30

     

       107
       107
       +
         > city: New York' | yamlcat

     

       108
       108
       +
         name: John

     

       109
       109
       +
         age: 30

     

       110
       110
       +
         city: New York

     

       111
       111
       +
       

     

       112
       112
       +
       Test 10: Inline - explicit start marker

     

       113
       113
       +
       ====================================

     

       114
       114
       +
       

     

       115
       115
       +
         $ echo '---

     

       116
       116
       +
         > name: Jane

     

       117
       117
       +
         > age: 25' | yamlcat

     

       118
       118
       +
         name: Jane

     

       119
       119
       +
         age: 25

     

       120
       120
       +
       

     

       121
       121
       +
       Test 11: Inline - explicit start and end markers

     

       122
       122
       +
       ====================================

     

       123
       123
       +
       

     

       124
       124
       +
         $ echo '---

     

       125
       125
       +
         > title: Example

     

       126
       126
       +
         > content: data

     

       127
       127
       +
         > ...' | yamlcat

     

       128
       128
       +
         title: Example

     

       129
       129
       +
         content: data

     

       130
       130
       +
       

     

       131
       131
       +
       Test 12: Inline - document with %YAML 1.2 directive

     

       132
       132
       +
       ====================================

     

       133
       133
       +
       

     

       134
       134
       +
         $ echo '%YAML 1.2

     

       135
       135
       +
         > ---

     

       136
       136
       +
         > version: 1.2

     

       137
       137
       +
         > enabled: true' | yamlcat

     

       138
       138
       +
         version: 1.2

     

       139
       139
       +
         enabled: true

     

       140
       140
       +
       

     

       141
       141
       +
       Test 13: Inline - document with comment before content

     

       142
       142
       +
       ====================================

     

       143
       143
       +
       

     

       144
       144
       +
         $ echo '# This is a comment

     

       145
       145
       +
         > name: Alice

     

       146
       146
       +
         > # Another comment

     

       147
       147
       +
         > value: 42' | yamlcat

     

       148
       148
       +
         name: Alice

     

       149
       149
       +
         value: 42

     

       150
       150
       +
       

     

       151
       151
       +
       Test 14: Inline - document with comment after directive

     

       152
       152
       +
       ====================================

     

       153
       153
       +
       

     

       154
       154
       +
         $ echo '%YAML 1.2

     

       155
       155
       +
         > # Comment after directive

     

       156
       156
       +
         > ---

     

       157
       157
       +
         > key: value' | yamlcat

     

       158
       158
       +
         key: value

     

       159
       159
       +
       

     

       160
       160
       +
       Test 15: Inline - explicit markers with comments

     

       161
       161
       +
       ====================================

     

       162
       162
       +
       

     

       163
       163
       +
         $ echo '---  # Document start

     

       164
       164
       +
         > data: content

     

       165
       165
       +
         > # Mid-document comment

     

       166
       166
       +
         > more: values

     

       167
       167
       +
         > ...  # Document end' | yamlcat

     

       168
       168
       +
         data: content

     

       169
       169
       +
         more: values

     

       170
       170
       +
       

     

       171
       171
       +
       Test 16: Verify JSON roundtrip for directive file

     

       172
       172
       +
       ====================================

     

       173
       173
       +
       

     

       174
       174
       +
         $ yamlcat --json directives.yml

     

       175
       175
       +
         {"version": "1.2", "content": "This document uses YAML 1.2"}

     

       176
       176
       +
       

     

       177
       177
       +
       Test 17: Verify JSON roundtrip for explicit markers

     

       178
       178
       +
       ====================================

     

       179
       179
       +
       

     

       180
       180
       +
         $ yamlcat --json documents_single_explicit_both.yml

     

       181
       181
       +
         {"key1": "value1", "key2": "value2", "nested": {"inner": "data"}, "list": ["item1", "item2", "item3"]}

     

       182
       182
       +
       

     

       183
       183
       +
       Test 18: Empty document with explicit markers

     

       184
       184
       +
       ====================================

     

       185
       185
       +
       

     

       186
       186
       +
         $ echo '---

     

       187
       187
       +
         > ...' | yamlcat

     

       188
       188
       +
         null

     

       189
       189
       +
       

     

       190
       190
       +
       Test 19: Document with only whitespace and markers

     

       191
       191
       +
       ====================================

     

       192
       192
       +
       

     

       193
       193
       +
         $ echo '---

     

       194
       194
       +
         > 

     

       195
       195
       +
         > ...' | yamlcat

     

       196
       196
       +
         null

     

       197
       197
       +
       

     

       198
       198
       +
       Test 20: Directive followed by content without explicit start

     

       199
       199
       +
       ====================================

     

       200
       200
       +
       

     

       201
       201
       +
         $ echo '%YAML 1.2

     

       202
       202
       +
         > simple: document' | yamlcat

     

       203
       203
       +
         Error: expected document start '---' at line 2, columns 1-1

     

       204
       204
       +
         [1]

+15

tests/cram/documents_multi.yml

···

       1
       1
       +
       # Multiple document variations

     

       2
       2
       +
       

     

       3
       3
       +
       # Test 1: Two documents separated by ---

     

       4
       4
       +
       ---

     

       5
       5
       +
       document: first

     

       6
       6
       +
       type: mapping

     

       7
       7
       +
       data:

     

       8
       8
       +
         key1: value1

     

       9
       9
       +
         key2: value2

     

       10
       10
       +
       ---

     

       11
       11
       +
       document: second

     

       12
       12
       +
       type: mapping

     

       13
       13
       +
       data:

     

       14
       14
       +
         key3: value3

     

       15
       15
       +
         key4: value4

+10

tests/cram/documents_multi_empty.yml

···

       1
       1
       +
       # Test 4: Empty documents

     

       2
       2
       +
       ---

     

       3
       3
       +
       # Empty document (implicitly null)

     

       4
       4
       +
       ---

     

       5
       5
       +
       key: value

     

       6
       6
       +
       ---

     

       7
       7
       +
       # Another empty document

     

       8
       8
       +
       ---

     

       9
       9
       +
       - item1

     

       10
       10
       +
       - item2

+15

tests/cram/documents_multi_three.yml

···

       1
       1
       +
       # Test 2: Three documents with different content types

     

       2
       2
       +
       ---

     

       3
       3
       +
       # First document: mapping

     

       4
       4
       +
       name: John Doe

     

       5
       5
       +
       age: 30

     

       6
       6
       +
       city: New York

     

       7
       7
       +
       ---

     

       8
       8
       +
       # Second document: sequence

     

       9
       9
       +
       - apple

     

       10
       10
       +
       - banana

     

       11
       11
       +
       - orange

     

       12
       12
       +
       - grape

     

       13
       13
       +
       ---

     

       14
       14
       +
       # Third document: scalar

     

       15
       15
       +
       This is a plain scalar document

+16

tests/cram/documents_multi_with_end.yml

···

       1
       1
       +
       # Test 3: Documents with explicit end markers

     

       2
       2
       +
       ---

     

       3
       3
       +
       first:

     

       4
       4
       +
         document: data1

     

       5
       5
       +
         value: 100

     

       6
       6
       +
       ...

     

       7
       7
       +
       ---

     

       8
       8
       +
       second:

     

       9
       9
       +
         document: data2

     

       10
       10
       +
         value: 200

     

       11
       11
       +
       ...

     

       12
       12
       +
       ---

     

       13
       13
       +
       third:

     

       14
       14
       +
         document: data3

     

       15
       15
       +
         value: 300

     

       16
       16
       +
       ...

+11

tests/cram/documents_single.yml

···

       1
       1
       +
       # Single document variations

     

       2
       2
       +
       

     

       3
       3
       +
       # Test 1: Implicit document (no markers)

     

       4
       4
       +
       key1: value1

     

       5
       5
       +
       key2: value2

     

       6
       6
       +
       nested:

     

       7
       7
       +
         inner: data

     

       8
       8
       +
       list:

     

       9
       9
       +
         - item1

     

       10
       10
       +
         - item2

     

       11
       11
       +
         - item3

+11

tests/cram/documents_single_explicit_both.yml

···

       1
       1
       +
       # Test 3: Explicit start and end (--- ... )

     

       2
       2
       +
       ---

     

       3
       3
       +
       key1: value1

     

       4
       4
       +
       key2: value2

     

       5
       5
       +
       nested:

     

       6
       6
       +
         inner: data

     

       7
       7
       +
       list:

     

       8
       8
       +
         - item1

     

       9
       9
       +
         - item2

     

       10
       10
       +
         - item3

     

       11
       11
       +
       ...

+10

tests/cram/documents_single_explicit_start.yml

···

       1
       1
       +
       # Test 2: Explicit start (---)

     

       2
       2
       +
       ---

     

       3
       3
       +
       key1: value1

     

       4
       4
       +
       key2: value2

     

       5
       5
       +
       nested:

     

       6
       6
       +
         inner: data

     

       7
       7
       +
       list:

     

       8
       8
       +
         - item1

     

       9
       9
       +
         - item2

     

       10
       10
       +
         - item3

+11

tests/cram/documents_single_with_directive.yml

···

       1
       1
       +
       # Test 4: With %YAML directive

     

       2
       2
       +
       %YAML 1.2

     

       3
       3
       +
       ---

     

       4
       4
       +
       key1: value1

     

       5
       5
       +
       key2: value2

     

       6
       6
       +
       nested:

     

       7
       7
       +
         inner: data

     

       8
       8
       +
       list:

     

       9
       9
       +
         - item1

     

       10
       10
       +
         - item2

     

       11
       11
       +
         - item3

tests/cram/dune

···

       1
       1
       +
       (cram

     

       2
       2
       +
        (deps

     

       3
       3
       +
         (package yamlrw)

     

       4
       4
       +
         (glob_files *.yml)))

+155

tests/cram/edge_cases.yml

···

       1
       1
       +
       # Edge cases test file for YAML parsing

     

       2
       2
       +
       

     

       3
       3
       +
       # Case 1: Keys with colons (must be quoted)

     

       4
       4
       +
       "key:with:colons": value

     

       5
       5
       +
       "http://example.com": url_as_key

     

       6
       6
       +
       "time:12:30": time_value

     

       7
       7
       +
       

     

       8
       8
       +
       # Case 2: Values starting with indicators (must be quoted or escaped)

     

       9
       9
       +
       indicator_square: "[this starts with bracket]"

     

       10
       10
       +
       indicator_curly: "{this starts with brace}"

     

       11
       11
       +
       indicator_star: "*this starts with star"

     

       12
       12
       +
       indicator_amp: "&this starts with ampersand"

     

       13
       13
       +
       indicator_question: "?this starts with question"

     

       14
       14
       +
       indicator_pipe: "|this starts with pipe"

     

       15
       15
       +
       indicator_gt: ">this starts with gt"

     

       16
       16
       +
       indicator_dash: "-this starts with dash"

     

       17
       17
       +
       indicator_hash: "#this starts with hash"

     

       18
       18
       +
       

     

       19
       19
       +
       # Case 3: Special string values that look like other types

     

       20
       20
       +
       string_true: "true"

     

       21
       21
       +
       string_false: "false"

     

       22
       22
       +
       string_null: "null"

     

       23
       23
       +
       string_number: "123"

     

       24
       24
       +
       string_float: "45.67"

     

       25
       25
       +
       string_yes: "yes"

     

       26
       26
       +
       string_no: "no"

     

       27
       27
       +
       

     

       28
       28
       +
       # Case 4: Actual special values

     

       29
       29
       +
       bool_true: true

     

       30
       30
       +
       bool_false: false

     

       31
       31
       +
       null_value: null

     

       32
       32
       +
       null_tilde: ~

     

       33
       33
       +
       number_int: 123

     

       34
       34
       +
       number_float: 45.67

     

       35
       35
       +
       number_exp: 1.23e4

     

       36
       36
       +
       number_hex: 0x1F

     

       37
       37
       +
       number_oct: 0o17

     

       38
       38
       +
       

     

       39
       39
       +
       # Case 5: Empty values

     

       40
       40
       +
       empty_string: ""

     

       41
       41
       +
       empty_list: []

     

       42
       42
       +
       empty_map: {}

     

       43
       43
       +
       null_implicit:

     

       44
       44
       +
       

     

       45
       45
       +
       # Case 6: Very long lines

     

       46
       46
       +
       very_long_key: "This is a very long value that contains a lot of text to test how the parser handles long lines. It should be able to handle lines that are much longer than typical lines in most YAML files. This continues for quite a while to make sure we test the boundaries of reasonable line lengths. Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."

     

       47
       47
       +
       

     

       48
       48
       +
       very_long_literal: |

     

       49
       49
       +
         This is a very long literal block that should preserve all the whitespace and newlines exactly as written. It can contain very long lines that go on and on and on without breaking. This tests whether the parser can handle long content in literal blocks properly. Lorem ipsum dolor sit amet, consectetur adipiscing elit.

     

       50
       50
       +
       

     

       51
       51
       +
       # Case 7: Unicode and special characters

     

       52
       52
       +
       unicode_emoji: "Hello 🌍 World 🚀"

     

       53
       53
       +
       unicode_chars: "Héllo Wörld 你好 مرحبا"

     

       54
       54
       +
       unicode_key_🔑: unicode_value

     

       55
       55
       +
       escaped_chars: "Line1\nLine2\tTabbed"

     

       56
       56
       +
       

     

       57
       57
       +
       # Case 8: Nested empty structures

     

       58
       58
       +
       nested_empty:

     

       59
       59
       +
         level1: {}

     

       60
       60
       +
         level2:

     

       61
       61
       +
           inner: []

     

       62
       62
       +
         level3:

     

       63
       63
       +
           inner:

     

       64
       64
       +
             deep: null

     

       65
       65
       +
       

     

       66
       66
       +
       # Case 9: Complex keys (flow collections as keys)

     

       67
       67
       +
       ? [complex, key]

     

       68
       68
       +
       : complex_value

     

       69
       69
       +
       ? {nested: key}

     

       70
       70
       +
       : another_value

     

       71
       71
       +
       

     

       72
       72
       +
       # Case 10: Multi-line keys and values

     

       73
       73
       +
       ? |

     

       74
       74
       +
         This is a multi-line

     

       75
       75
       +
         key using literal block

     

       76
       76
       +
       : |

     

       77
       77
       +
         This is a multi-line

     

       78
       78
       +
         value using literal block

     

       79
       79
       +
       

     

       80
       80
       +
       # Case 11: Quoted strings with escape sequences

     

       81
       81
       +
       single_quoted: 'It''s a single-quoted string with doubled quotes'

     

       82
       82
       +
       double_quoted: "It's a \"double-quoted\" string with escapes"

     

       83
       83
       +
       backslash: "Path\\to\\file"

     

       84
       84
       +
       newline_escape: "First line\nSecond line"

     

       85
       85
       +
       

     

       86
       86
       +
       # Case 12: Anchors and aliases at edge positions

     

       87
       87
       +
       anchor_list: &anchor_ref

     

       88
       88
       +
         - item1

     

       89
       89
       +
         - item2

     

       90
       90
       +
         - item3

     

       91
       91
       +
       

     

       92
       92
       +
       alias_usage: *anchor_ref

     

       93
       93
       +
       

     

       94
       94
       +
       nested_anchor:

     

       95
       95
       +
         data: &nested_ref

     

       96
       96
       +
           key: value

     

       97
       97
       +
         reference: *nested_ref

     

       98
       98
       +
       

     

       99
       99
       +
       # Case 13: Mixed flow and block styles

     

       100
       100
       +
       mixed_style:

     

       101
       101
       +
         block_key:

     

       102
       102
       +
           - flow_in_block: [1, 2, 3]

     

       103
       103
       +
           - another: {a: 1, b: 2}

     

       104
       104
       +
         flow_key: {block_in_flow:

     

       105
       105
       +
           - item1

     

       106
       106
       +
           - item2}

     

       107
       107
       +
       

     

       108
       108
       +
       # Case 14: Trailing commas in flow (typically invalid in YAML)

     

       109
       109
       +
       # flow_trailing: [1, 2, 3,]  # This would be invalid

     

       110
       110
       +
       

     

       111
       111
       +
       # Case 15: Strings that need quoting

     

       112
       112
       +
       needs_quote_1: "value with # in it"

     

       113
       113
       +
       needs_quote_2: "value with: colon"

     

       114
       114
       +
       needs_quote_3: "value with @ at sign"

     

       115
       115
       +
       needs_quote_4: "value with ` backtick"

     

       116
       116
       +
       

     

       117
       117
       +
       # Case 16: Multiple documents separator (not starting a new document)

     

       118
       118
       +
       not_doc_separator: "--- this is just a string value"

     

       119
       119
       +
       

     

       120
       120
       +
       # Case 17: Extremely nested structures

     

       121
       121
       +
       deeply_nested:

     

       122
       122
       +
         l1:

     

       123
       123
       +
           l2:

     

       124
       124
       +
             l3:

     

       125
       125
       +
               l4:

     

       126
       126
       +
                 l5:

     

       127
       127
       +
                   l6:

     

       128
       128
       +
                     l7:

     

       129
       129
       +
                       l8:

     

       130
       130
       +
                         l9:

     

       131
       131
       +
                           l10: "deep value"

     

       132
       132
       +
       

     

       133
       133
       +
       # Case 18: Large sequence

     

       134
       134
       +
       large_sequence:

     

       135
       135
       +
         - item_001

     

       136
       136
       +
         - item_002

     

       137
       137
       +
         - item_003

     

       138
       138
       +
         - item_004

     

       139
       139
       +
         - item_005

     

       140
       140
       +
         - item_006

     

       141
       141
       +
         - item_007

     

       142
       142
       +
         - item_008

     

       143
       143
       +
         - item_009

     

       144
       144
       +
         - item_010

     

       145
       145
       +
       

     

       146
       146
       +
       # Case 19: Keys and values with only whitespace differences

     

       147
       147
       +
       " key": "value with leading space in key"

     

       148
       148
       +
       "key ": "value with trailing space in key"

     

       149
       149
       +
       "  spaced  ": "  spaced  "

     

       150
       150
       +
       

     

       151
       151
       +
       # Case 20: Binary-looking values

     

       152
       152
       +
       binary_string: "0b101010"

     

       153
       153
       +
       hex_string: "0xDEADBEEF"

     

       154
       154
       +
       

     

       155
       155
       +
       # End of edge cases test file

+49

tests/cram/empty_collections.t

···

       1
       1
       +
       Empty Collection YAML Emission

     

       2
       2
       +
       

     

       3
       3
       +
       These tests verify that empty sequences and mappings are correctly emitted

     

       4
       4
       +
       as [] and {} in YAML output.

     

       5
       5
       +
       

     

       6
       6
       +
       Test: Empty sequence

     

       7
       7
       +
       

     

       8
       8
       +
         $ echo 'empty_seq: []' | yamlcat

     

       9
       9
       +
         empty_seq: []

     

       10
       10
       +
       

     

       11
       11
       +
       Test: Empty mapping

     

       12
       12
       +
       

     

       13
       13
       +
         $ echo 'empty_map: {}' | yamlcat

     

       14
       14
       +
         empty_map: {}

     

       15
       15
       +
       

     

       16
       16
       +
       Test: Multiple empty collections

     

       17
       17
       +
       

     

       18
       18
       +
         $ echo 'seq: []

     

       19
       19
       +
         > map: {}

     

       20
       20
       +
         > data: value' | yamlcat

     

       21
       21
       +
         seq: []

     

       22
       22
       +
         map: {}

     

       23
       23
       +
         data: value

     

       24
       24
       +
       

     

       25
       25
       +
       Test: Nested empty collections

     

       26
       26
       +
       

     

       27
       27
       +
         $ echo 'outer:

     

       28
       28
       +
         >   inner_seq: []

     

       29
       29
       +
         >   inner_map: {}' | yamlcat

     

       30
       30
       +
         outer:

     

       31
       31
       +
           inner_seq: []

     

       32
       32
       +
           inner_map: {}

     

       33
       33
       +
       

     

       34
       34
       +
       Test: Empty collection in sequence

     

       35
       35
       +
       

     

       36
       36
       +
         $ echo 'items:

     

       37
       37
       +
         >   - first

     

       38
       38
       +
         >   - []

     

       39
       39
       +
         >   - third' | yamlcat

     

       40
       40
       +
         items:

     

       41
       41
       +
           - first

     

       42
       42
       +
           - []

     

       43
       43
       +
           - third

     

       44
       44
       +
       

     

       45
       45
       +
       Test: Verify JSON output is correct (for comparison)

     

       46
       46
       +
       

     

       47
       47
       +
         $ echo 'empty_seq: []

     

       48
       48
       +
         > empty_map: {}' | yamlcat --json

     

       49
       49
       +
         {"empty_seq": [], "empty_map": {}}

tests/cram/escaped_newline.yml

···

       1
       1
       +
       text: "Line one\nLine two"

+45

tests/cram/failing_escapes.t

···

       1
       1
       +
       Escape Sequence Issues (documentation of known edge cases)

     

       2
       2
       +
       

     

       3
       3
       +
       These tests document escape sequence handling edge cases.

     

       4
       4
       +
       

     

       5
       5
       +
       The primary issue is with \U (capital U) in double-quoted strings.

     

       6
       6
       +
       In YAML, \U is a 32-bit unicode escape that expects 8 hex digits.

     

       7
       7
       +
       When users write paths like "C:\Users" the \U is interpreted as

     

       8
       8
       +
       a unicode escape but "sers" are not valid hex digits.

     

       9
       9
       +
       

     

       10
       10
       +
       Test: Capital U interpreted as unicode escape

     

       11
       11
       +
       

     

       12
       12
       +
         $ echo 'path: "C:\\Users\\Name"' | yamlcat --json 2>&1

     

       13
       13
       +
         Error: invalid hex escape:  at line 1, columns 12-12

     

       14
       14
       +
         [1]

     

       15
       15
       +
       

     

       16
       16
       +
       This fails because:

     

       17
       17
       +
       - Shell: echo 'C:\\Users\\Name' produces C:\Users\Name

     

       18
       18
       +
       - YAML sees: "C:\Users\Name"

     

       19
       19
       +
       - \U is a 32-bit unicode escape (expects \UHHHHHHHH)

     

       20
       20
       +
       - "sers" are not 8 hex digits, so it fails

     

       21
       21
       +
       

     

       22
       22
       +
       Test: Lowercase u unicode escape works

     

       23
       23
       +
       

     

       24
       24
       +
         $ echo 'unicode: "\\u0041"' | yamlcat --json

     

       25
       25
       +
         {"unicode": "A"}

     

       26
       26
       +
       

     

       27
       27
       +
       Test: Uppercase U requires 8 hex digits

     

       28
       28
       +
       

     

       29
       29
       +
         $ echo 'unicode: "\\U00000041"' | yamlcat --json

     

       30
       30
       +
         {"unicode": "A"}

     

       31
       31
       +
       

     

       32
       32
       +
       Test: Backslash escaping works for non-unicode

     

       33
       33
       +
       

     

       34
       34
       +
         $ echo 'escaped: "one\\\\two\\\\three"' | yamlcat --json

     

       35
       35
       +
         {"escaped": "one\\two\\three"}

     

       36
       36
       +
       

     

       37
       37
       +
       Test: Mixed valid escapes

     

       38
       38
       +
       

     

       39
       39
       +
         $ echo 'text: "Tab:\\t Newline:\\n Quote:\\\\"' | yamlcat --json

     

       40
       40
       +
         {"text": "Tab:\t Newline:\n Quote:\\"}

     

       41
       41
       +
       

     

       42
       42
       +
       Test: Backslash a is bell character

     

       43
       43
       +
       

     

       44
       44
       +
         $ echo 'text: "test\\a"' | yamlcat --json

     

       45
       45
       +
         {"text": "test\007"}

+42

tests/cram/invalid_floats.t

···

       1
       1
       +
       Test that invalid float representations are treated as strings

     

       2
       2
       +
       (See: https://github.com/avsm/ocaml-yaml/issues/82)

     

       3
       3
       +
       

     

       4
       4
       +
       Per YAML spec, only .nan/.NaN/.NAN (with leading dot) are valid NaN values,

     

       5
       5
       +
       and only .inf/.Inf/.INF (with leading dot) are valid infinity values.

     

       6
       6
       +
       

     

       7
       7
       +
       OCaml's Float.of_string accepts "nan", "inf", "infinity" without the dot,

     

       8
       8
       +
       which causes incorrect parsing if used as a fallback.

     

       9
       9
       +
       

     

       10
       10
       +
         $ yamlcat invalid_floats.yml

     

       11
       11
       +
         valid_nan: .nan

     

       12
       12
       +
         valid_nan_title: .nan

     

       13
       13
       +
         valid_nan_upper: .nan

     

       14
       14
       +
         valid_inf: .inf

     

       15
       15
       +
         valid_inf_title: .inf

     

       16
       16
       +
         valid_inf_upper: .inf

     

       17
       17
       +
         valid_neg_inf: -.inf

     

       18
       18
       +
         valid_neg_inf_title: -.inf

     

       19
       19
       +
         valid_neg_inf_upper: -.inf

     

       20
       20
       +
         valid_pos_inf: .inf

     

       21
       21
       +
         invalid_nan: 'nan'

     

       22
       22
       +
         invalid_nan_title: 'NaN'

     

       23
       23
       +
         invalid_nan_upper: 'NAN'

     

       24
       24
       +
         invalid_inf: 'inf'

     

       25
       25
       +
         invalid_inf_title: 'Inf'

     

       26
       26
       +
         invalid_inf_upper: 'INF'

     

       27
       27
       +
         invalid_infinity: 'infinity'

     

       28
       28
       +
         invalid_infinity_title: 'Infinity'

     

       29
       29
       +
         invalid_infinity_upper: 'INFINITY'

     

       30
       30
       +
         invalid_neg_inf: '-inf'

     

       31
       31
       +
         invalid_neg_infinity: '-infinity'

     

       32
       32
       +
         invalid_pos_inf: '+inf'

     

       33
       33
       +
         invalid_pos_infinity: '+infinity'

     

       34
       34
       +
         quoted_nan: 'nan'

     

       35
       35
       +
         quoted_inf: 'inf'

     

       36
       36
       +
         quoted_infinity: 'infinity'

     

       37
       37
       +
         dependencies:

     

       38
       38
       +
           'nan': 2.14.0

     

       39
       39
       +
           'inf': 1.0.0

     

       40
       40
       +
       

     

       41
       41
       +
         $ yamlcat --json invalid_floats.yml

     

       42
       42
       +
         {"valid_nan": nan, "valid_nan_title": nan, "valid_nan_upper": nan, "valid_inf": inf, "valid_inf_title": inf, "valid_inf_upper": inf, "valid_neg_inf": -inf, "valid_neg_inf_title": -inf, "valid_neg_inf_upper": -inf, "valid_pos_inf": inf, "invalid_nan": "nan", "invalid_nan_title": "NaN", "invalid_nan_upper": "NAN", "invalid_inf": "inf", "invalid_inf_title": "Inf", "invalid_inf_upper": "INF", "invalid_infinity": "infinity", "invalid_infinity_title": "Infinity", "invalid_infinity_upper": "INFINITY", "invalid_neg_inf": "-inf", "invalid_neg_infinity": "-infinity", "invalid_pos_inf": "+inf", "invalid_pos_infinity": "+infinity", "quoted_nan": "nan", "quoted_inf": "inf", "quoted_infinity": "infinity", "dependencies": {"nan": "2.14.0", "inf": "1.0.0"}}

+40

tests/cram/invalid_floats.yml

···

       1
       1
       +
       # Test that invalid float representations are treated as strings

     

       2
       2
       +
       # Per YAML spec, only .nan/.NaN/.NAN and .inf/.Inf/.INF (with dot) are valid

     

       3
       3
       +
       

     

       4
       4
       +
       # These should be floats (valid YAML float syntax)

     

       5
       5
       +
       valid_nan: .nan

     

       6
       6
       +
       valid_nan_title: .NaN

     

       7
       7
       +
       valid_nan_upper: .NAN

     

       8
       8
       +
       valid_inf: .inf

     

       9
       9
       +
       valid_inf_title: .Inf

     

       10
       10
       +
       valid_inf_upper: .INF

     

       11
       11
       +
       valid_neg_inf: -.inf

     

       12
       12
       +
       valid_neg_inf_title: -.Inf

     

       13
       13
       +
       valid_neg_inf_upper: -.INF

     

       14
       14
       +
       valid_pos_inf: +.inf

     

       15
       15
       +
       

     

       16
       16
       +
       # These should be STRINGS (invalid YAML float syntax, but OCaml float_of_string accepts them)

     

       17
       17
       +
       # See: https://github.com/avsm/ocaml-yaml/issues/82

     

       18
       18
       +
       invalid_nan: nan

     

       19
       19
       +
       invalid_nan_title: NaN

     

       20
       20
       +
       invalid_nan_upper: NAN

     

       21
       21
       +
       invalid_inf: inf

     

       22
       22
       +
       invalid_inf_title: Inf

     

       23
       23
       +
       invalid_inf_upper: INF

     

       24
       24
       +
       invalid_infinity: infinity

     

       25
       25
       +
       invalid_infinity_title: Infinity

     

       26
       26
       +
       invalid_infinity_upper: INFINITY

     

       27
       27
       +
       invalid_neg_inf: -inf

     

       28
       28
       +
       invalid_neg_infinity: -infinity

     

       29
       29
       +
       invalid_pos_inf: +inf

     

       30
       30
       +
       invalid_pos_infinity: +infinity

     

       31
       31
       +
       

     

       32
       32
       +
       # Quoted versions should always be strings

     

       33
       33
       +
       quoted_nan: 'nan'

     

       34
       34
       +
       quoted_inf: 'inf'

     

       35
       35
       +
       quoted_infinity: 'infinity'

     

       36
       36
       +
       

     

       37
       37
       +
       # As mapping keys (yarn.lock use case)

     

       38
       38
       +
       dependencies:

     

       39
       39
       +
         nan: 2.14.0

     

       40
       40
       +
         inf: 1.0.0

+59

tests/cram/linuxkit.yml

···

       1
       1
       +
       kernel:

     

       2
       2
       +
         image: linuxkit/kernel:4.9.40

     

       3
       3
       +
         cmdline: "console=tty0 console=ttyS0"

     

       4
       4
       +
       init:

     

       5
       5
       +
         - linuxkit/init:906e174b3f2e07f97d6fd693a2e8518e98dafa58

     

       6
       6
       +
         - linuxkit/runc:90e45f13e1d0a0983f36ef854621e3eac91cf541

     

       7
       7
       +
         - linuxkit/containerd:7c986fb7df33bea73b5c8097b46989e46f49d875

     

       8
       8
       +
         - linuxkit/ca-certificates:e44b0a66df5a102c0e220f0066b0d904710dcb10

     

       9
       9
       +
       onboot:

     

       10
       10
       +
         - name: sysctl

     

       11
       11
       +
           image: linuxkit/sysctl:184c914d23a017062d7b53d7fc1dfaf47764bef6

     

       12
       12
       +
         - name: dhcpcd

     

       13
       13
       +
           image: linuxkit/dhcpcd:f3f5413abb78fae9020e35bd4788fa93df4530b7

     

       14
       14
       +
           command: ["/sbin/dhcpcd", "--nobackground", "-f", "/dhcpcd.conf", "-1"]

     

       15
       15
       +
       onshutdown:

     

       16
       16
       +
         - name: shutdown

     

       17
       17
       +
           image: busybox:latest

     

       18
       18
       +
           command: ["/bin/echo", "so long and thanks for all the fish"]

     

       19
       19
       +
       services:

     

       20
       20
       +
         - name: getty

     

       21
       21
       +
           image: linuxkit/getty:2c841cdc34396e3fa8f25b62d112808f63f16df6

     

       22
       22
       +
           env:

     

       23
       23
       +
            - INSECURE=true

     

       24
       24
       +
         - name: rngd

     

       25
       25
       +
           image: linuxkit/rngd:b2f4bdcb55aa88a25c86733e294628614504f383

     

       26
       26
       +
         - name: nginx

     

       27
       27
       +
           image: nginx:alpine

     

       28
       28
       +
           capabilities:

     

       29
       29
       +
            - CAP_NET_BIND_SERVICE

     

       30
       30
       +
            - CAP_CHOWN

     

       31
       31
       +
            - CAP_SETUID

     

       32
       32
       +
            - CAP_SETGID

     

       33
       33
       +
            - CAP_DAC_OVERRIDE

     

       34
       34
       +
       files:

     

       35
       35
       +
         - path: etc/containerd/config.toml

     

       36
       36
       +
           contents: |

     

       37
       37
       +
             state = "/run/containerd"

     

       38
       38
       +
             root = "/var/lib/containerd"

     

       39
       39
       +
             snapshotter = "io.containerd.snapshotter.v1.overlayfs"

     

       40
       40
       +
             differ = "io.containerd.differ.v1.base-diff"

     

       41
       41
       +
             subreaper = false

     

       42
       42
       +
       

     

       43
       43
       +
             [grpc]

     

       44
       44
       +
             address = "/run/containerd/containerd.sock"

     

       45
       45
       +
             uid = 0

     

       46
       46
       +
             gid = 0

     

       47
       47
       +
       

     

       48
       48
       +
             [debug]

     

       49
       49
       +
             address = "/run/containerd/debug.sock"

     

       50
       50
       +
             level = "info"

     

       51
       51
       +
       

     

       52
       52
       +
             [metrics]

     

       53
       53
       +
             address = ":13337"

     

       54
       54
       +
         - path: etc/linuxkit-config

     

       55
       55
       +
           metadata: yaml

     

       56
       56
       +
       trust:

     

       57
       57
       +
         org:

     

       58
       58
       +
           - linuxkit

     

       59
       59
       +
           - library

+407

tests/cram/multidoc.t

···

       1
       1
       +
       Multi-document stream support (currently not supported)

     

       2
       2
       +
       

     

       3
       3
       +
       These tests document expected behavior for multi-document YAML streams.

     

       4
       4
       +
       They currently fail with "multiple documents found when single expected".

     

       5
       5
       +
       

     

       6
       6
       +
       Test: Two documents separated by ---

     

       7
       7
       +
       

     

       8
       8
       +
         $ echo '---

     

       9
       9
       +
         > first: document

     

       10
       10
       +
         > ---

     

       11
       11
       +
         > second: document' | yamlcat 2>&1

     

       12
       12
       +
         first: document

     

       13
       13
       +
         ---

     

       14
       14
       +
         second: document

     

       15
       15
       +
       

     

       16
       16
       +
       Test: Three documents with different types

     

       17
       17
       +
       

     

       18
       18
       +
         $ echo '---

     

       19
       19
       +
         > mapping: value

     

       20
       20
       +
         > ---

     

       21
       21
       +
         > - sequence

     

       22
       22
       +
         > - items

     

       23
       23
       +
         > ---

     

       24
       24
       +
         > scalar value' | yamlcat 2>&1

     

       25
       25
       +
         mapping: value

     

       26
       26
       +
         ---

     

       27
       27
       +
         - sequence

     

       28
       28
       +
         - items

     

       29
       29
       +
         ---

     

       30
       30
       +
         scalar value

     

       31
       31
       +
       

     

       32
       32
       +
       Test: Documents with explicit end markers

     

       33
       33
       +
       

     

       34
       34
       +
         $ echo '---

     

       35
       35
       +
         > doc1: value

     

       36
       36
       +
         > ...

     

       37
       37
       +
         > ---

     

       38
       38
       +
         > doc2: value

     

       39
       39
       +
         > ...' | yamlcat 2>&1

     

       40
       40
       +
         doc1: value

     

       41
       41
       +
         ---

     

       42
       42
       +
         doc2: value

     

       43
       43
       +
       

     

       44
       44
       +
       Test: Empty documents

     

       45
       45
       +
       

     

       46
       46
       +
         $ echo '---

     

       47
       47
       +
         > ---

     

       48
       48
       +
         > content: here

     

       49
       49
       +
         > ---' | yamlcat 2>&1

     

       50
       50
       +
         null

     

       51
       51
       +
         ---

     

       52
       52
       +
         content: here

     

       53
       53
       +
         ---

     

       54
       54
       +
         null

     

       55
       55
       +
       

     

       56
       56
       +
       Test: Multi-document file

     

       57
       57
       +
       

     

       58
       58
       +
         $ yamlcat documents_multi.yml 2>&1

     

       59
       59
       +
         document: first

     

       60
       60
       +
         type: mapping

     

       61
       61
       +
         data:

     

       62
       62
       +
           key1: value1

     

       63
       63
       +
           key2: value2

     

       64
       64
       +
         ---

     

       65
       65
       +
         document: second

     

       66
       66
       +
         type: mapping

     

       67
       67
       +
         data:

     

       68
       68
       +
           key3: value3

     

       69
       69
       +
           key4: value4

     

       70
       70
       +
       

     

       71
       71
       +
         $ yamlcat documents_multi_three.yml 2>&1

     

       72
       72
       +
         name: John Doe

     

       73
       73
       +
         age: 30

     

       74
       74
       +
         city: New York

     

       75
       75
       +
         ---

     

       76
       76
       +
         - apple

     

       77
       77
       +
         - banana

     

       78
       78
       +
         - orange

     

       79
       79
       +
         - grape

     

       80
       80
       +
         ---

     

       81
       81
       +
         This is a plain scalar document

     

       82
       82
       +
       

     

       83
       83
       +
         $ yamlcat documents_multi_with_end.yml 2>&1

     

       84
       84
       +
         first:

     

       85
       85
       +
           document: data1

     

       86
       86
       +
           value: 100

     

       87
       87
       +
         ---

     

       88
       88
       +
         second:

     

       89
       89
       +
           document: data2

     

       90
       90
       +
           value: 200

     

       91
       91
       +
         ---

     

       92
       92
       +
         third:

     

       93
       93
       +
           document: data3

     

       94
       94
       +
           value: 300

     

       95
       95
       +
       

     

       96
       96
       +
         $ yamlcat documents_multi_empty.yml 2>&1

     

       97
       97
       +
         null

     

       98
       98
       +
         ---

     

       99
       99
       +
         key: value

     

       100
       100
       +
         ---

     

       101
       101
       +
         null

     

       102
       102
       +
         ---

     

       103
       103
       +
         - item1

     

       104
       104
       +
         - item2

     

       105
       105
       +
       

     

       106
       106
       +
       Test: Anchors file (uses multiple documents)

     

       107
       107
       +
       

     

       108
       108
       +
         $ yamlcat anchors_basic.yml 2>&1

     

       109
       109
       +
         scalar_anchor: Hello, World!

     

       110
       110
       +
         scalar_alias: Hello, World!

     

       111
       111
       +
         ---

     

       112
       112
       +
         original: 42

     

       113
       113
       +
         copy: 42

     

       114
       114
       +
         another_copy: 42

     

       115
       115
       +
         ---

     

       116
       116
       +
         original_list:

     

       117
       117
       +
           - apple

     

       118
       118
       +
           - banana

     

       119
       119
       +
           - cherry

     

       120
       120
       +
         copied_list:

     

       121
       121
       +
           - apple

     

       122
       122
       +
           - banana

     

       123
       123
       +
           - cherry

     

       124
       124
       +
         ---

     

       125
       125
       +
         original_map:

     

       126
       126
       +
           name: Alice

     

       127
       127
       +
           age: 30

     

       128
       128
       +
           city: London

     

       129
       129
       +
         copied_map:

     

       130
       130
       +
           name: Alice

     

       131
       131
       +
           age: 30

     

       132
       132
       +
           city: London

     

       133
       133
       +
         ---

     

       134
       134
       +
         defaults:

     

       135
       135
       +
           timeout: 30

     

       136
       136
       +
           retries: 3

     

       137
       137
       +
         colors:

     

       138
       138
       +
           - red

     

       139
       139
       +
           - green

     

       140
       140
       +
           - blue

     

       141
       141
       +
         config:

     

       142
       142
       +
           settings:

     

       143
       143
       +
             timeout: 30

     

       144
       144
       +
             retries: 3

     

       145
       145
       +
           palette:

     

       146
       146
       +
             - red

     

       147
       147
       +
             - green

     

       148
       148
       +
             - blue

     

       149
       149
       +
         ---

     

       150
       150
       +
         template:

     

       151
       151
       +
           metadata:

     

       152
       152
       +
             version: 1

     

       153
       153
       +
             author: John Doe

     

       154
       154
       +
           settings:

     

       155
       155
       +
             enabled: true

     

       156
       156
       +
             debug: false

     

       157
       157
       +
         instance1:

     

       158
       158
       +
           metadata:

     

       159
       159
       +
             version: 1

     

       160
       160
       +
             author: John Doe

     

       161
       161
       +
           settings:

     

       162
       162
       +
             enabled: true

     

       163
       163
       +
             debug: false

     

       164
       164
       +
         instance2:

     

       165
       165
       +
           metadata:

     

       166
       166
       +
             version: 1

     

       167
       167
       +
             author: John Doe

     

       168
       168
       +
           settings:

     

       169
       169
       +
             enabled: true

     

       170
       170
       +
             debug: false

     

       171
       171
       +
         ---

     

       172
       172
       +
         items:

     

       173
       173
       +
           - id: 1

     

       174
       174
       +
             name: First

     

       175
       175
       +
           - id: 2

     

       176
       176
       +
             name: Second

     

       177
       177
       +
           - id: 1

     

       178
       178
       +
             name: First

     

       179
       179
       +
         ---

     

       180
       180
       +
         shared_value: 100

     

       181
       181
       +
         calculations:

     

       182
       182
       +
           base: 100

     

       183
       183
       +
           doubled: 200

     

       184
       184
       +
           reference: 100

     

       185
       185
       +
           another_ref: 100

     

       186
       186
       +
         ---

     

       187
       187
       +
         feature_flag: true

     

       188
       188
       +
         features:

     

       189
       189
       +
           login: true

     

       190
       190
       +
           signup: true

     

       191
       191
       +
           export: true

     

       192
       192
       +
         ---

     

       193
       193
       +
         empty: null

     

       194
       194
       +
         values:

     

       195
       195
       +
           first: null

     

       196
       196
       +
           second: null

     

       197
       197
       +
         ---

     

       198
       198
       +
         message: "This is a multi-line\nmessage with some\nspecial content!\n"

     

       199
       199
       +
         output1: "This is a multi-line\nmessage with some\nspecial content!\n"

     

       200
       200
       +
         output2: "This is a multi-line\nmessage with some\nspecial content!\n"

     

       201
       201
       +
         ---

     

       202
       202
       +
         database:

     

       203
       203
       +
           primary:

     

       204
       204
       +
             host: localhost

     

       205
       205
       +
             port: 5432

     

       206
       206
       +
             ssl: true

     

       207
       207
       +
           replica:

     

       208
       208
       +
             host: localhost

     

       209
       209
       +
             port: 5432

     

       210
       210
       +
             ssl: true

     

       211
       211
       +
           backup:

     

       212
       212
       +
             host: localhost

     

       213
       213
       +
             port: 5432

     

       214
       214
       +
             ssl: true

     

       215
       215
       +
       

     

       216
       216
       +
         $ yamlcat anchors_merge.yml 2>&1

     

       217
       217
       +
         defaults:

     

       218
       218
       +
           timeout: 30

     

       219
       219
       +
           retries: 3

     

       220
       220
       +
           verbose: false

     

       221
       221
       +
         production:

     

       222
       222
       +
           <<:

     

       223
       223
       +
             timeout: 30

     

       224
       224
       +
             retries: 3

     

       225
       225
       +
             verbose: false

     

       226
       226
       +
           environment: production

     

       227
       227
       +
         ---

     

       228
       228
       +
         base:

     

       229
       229
       +
           color: red

     

       230
       230
       +
           size: medium

     

       231
       231
       +
           weight: 100

     

       232
       232
       +
         custom:

     

       233
       233
       +
           <<:

     

       234
       234
       +
             color: red

     

       235
       235
       +
             size: medium

     

       236
       236
       +
             weight: 100

     

       237
       237
       +
           color: blue

     

       238
       238
       +
           shape: circle

     

       239
       239
       +
         ---

     

       240
       240
       +
         connection:

     

       241
       241
       +
           host: localhost

     

       242
       242
       +
           port: 8080

     

       243
       243
       +
         authentication:

     

       244
       244
       +
           username: admin

     

       245
       245
       +
           password: secret

     

       246
       246
       +
         server:

     

       247
       247
       +
           <<:

     

       248
       248
       +
             - host: localhost

     

       249
       249
       +
               port: 8080

     

       250
       250
       +
             - username: admin

     

       251
       251
       +
               password: secret

     

       252
       252
       +
           ssl: true

     

       253
       253
       +
         ---

     

       254
       254
       +
         defaults:

     

       255
       255
       +
           timeout: 30

     

       256
       256
       +
           retries: 3

     

       257
       257
       +
         advanced:

     

       258
       258
       +
           cache: true

     

       259
       259
       +
           pool_size: 10

     

       260
       260
       +
         config:

     

       261
       261
       +
           <<:

     

       262
       262
       +
             - timeout: 30

     

       263
       263
       +
               retries: 3

     

       264
       264
       +
             - cache: true

     

       265
       265
       +
               pool_size: 10

     

       266
       266
       +
           timeout: 60

     

       267
       267
       +
           custom: value

     

       268
       268
       +
         ---

     

       269
       269
       +
         base_style:

     

       270
       270
       +
           font: Arial

     

       271
       271
       +
           size: 12

     

       272
       272
       +
         heading_defaults:

     

       273
       273
       +
           <<:

     

       274
       274
       +
             font: Arial

     

       275
       275
       +
             size: 12

     

       276
       276
       +
           weight: bold

     

       277
       277
       +
         main_heading:

     

       278
       278
       +
           <<:

     

       279
       279
       +
             <<:

     

       280
       280
       +
               font: Arial

     

       281
       281
       +
               size: 12

     

       282
       282
       +
             weight: bold

     

       283
       283
       +
           size: 18

     

       284
       284
       +
           color: navy

     

       285
       285
       +
         ---

     

       286
       286
       +
         common:

     

       287
       287
       +
           enabled: true

     

       288
       288
       +
           log_level: info

     

       289
       289
       +
         services:

     

       290
       290
       +
           - name: web

     

       291
       291
       +
             <<:

     

       292
       292
       +
               enabled: true

     

       293
       293
       +
               log_level: info

     

       294
       294
       +
             port: 80

     

       295
       295
       +
           - name: api

     

       296
       296
       +
             <<:

     

       297
       297
       +
               enabled: true

     

       298
       298
       +
               log_level: info

     

       299
       299
       +
             port: 3000

     

       300
       300
       +
           - name: worker

     

       301
       301
       +
             <<:

     

       302
       302
       +
               enabled: true

     

       303
       303
       +
               log_level: info

     

       304
       304
       +
             threads: 4

     

       305
       305
       +
         ---

     

       306
       306
       +
         empty: {}

     

       307
       307
       +
         config:

     

       308
       308
       +
           <<: {}

     

       309
       309
       +
           key: value

     

       310
       310
       +
         ---

     

       311
       311
       +
         metadata:

     

       312
       312
       +
           created: 2023-01-01

     

       313
       313
       +
           author: Admin

     

       314
       314
       +
           tags:

     

       315
       315
       +
             - v1

     

       316
       316
       +
             - stable

     

       317
       317
       +
         document:

     

       318
       318
       +
           <<:

     

       319
       319
       +
             created: 2023-01-01

     

       320
       320
       +
             author: Admin

     

       321
       321
       +
             tags:

     

       322
       322
       +
               - v1

     

       323
       323
       +
               - stable

     

       324
       324
       +
           title: Important Document

     

       325
       325
       +
           content: Some content here

     

       326
       326
       +
         ---

     

       327
       327
       +
         level1:

     

       328
       328
       +
           a: 1

     

       329
       329
       +
           b: 2

     

       330
       330
       +
         level2:

     

       331
       331
       +
           <<:

     

       332
       332
       +
             a: 1

     

       333
       333
       +
             b: 2

     

       334
       334
       +
           c: 3

     

       335
       335
       +
         level3:

     

       336
       336
       +
           <<:

     

       337
       337
       +
             <<:

     

       338
       338
       +
               a: 1

     

       339
       339
       +
               b: 2

     

       340
       340
       +
             c: 3

     

       341
       341
       +
           d: 4

     

       342
       342
       +
         ---

     

       343
       343
       +
         first:

     

       344
       344
       +
           name: First

     

       345
       345
       +
           value: 100

     

       346
       346
       +
           priority: low

     

       347
       347
       +
         second:

     

       348
       348
       +
           name: Second

     

       349
       349
       +
           value: 200

     

       350
       350
       +
           category: important

     

       351
       351
       +
         combined:

     

       352
       352
       +
           <<:

     

       353
       353
       +
             - name: First

     

       354
       354
       +
               value: 100

     

       355
       355
       +
               priority: low

     

       356
       356
       +
             - name: Second

     

       357
       357
       +
               value: 200

     

       358
       358
       +
               category: important

     

       359
       359
       +
           name: Combined

     

       360
       360
       +
         ---

     

       361
       361
       +
         numbers:

     

       362
       362
       +
           count: 42

     

       363
       363
       +
           ratio: 3.14

     

       364
       364
       +
           active: true

     

       365
       365
       +
         derived:

     

       366
       366
       +
           <<:

     

       367
       367
       +
             count: 42

     

       368
       368
       +
             ratio: 3.14

     

       369
       369
       +
             active: true

     

       370
       370
       +
           label: Test

     

       371
       371
       +
         ---

     

       372
       372
       +
         db_defaults:

     

       373
       373
       +
           pool_size: 5

     

       374
       374
       +
           timeout: 30

     

       375
       375
       +
           ssl: false

     

       376
       376
       +
         cache_defaults:

     

       377
       377
       +
           ttl: 3600

     

       378
       378
       +
           max_size: 1000

     

       379
       379
       +
         development:

     

       380
       380
       +
           database:

     

       381
       381
       +
             <<:

     

       382
       382
       +
               pool_size: 5

     

       383
       383
       +
               timeout: 30

     

       384
       384
       +
               ssl: false

     

       385
       385
       +
             host: localhost

     

       386
       386
       +
             name: dev_db

     

       387
       387
       +
           cache:

     

       388
       388
       +
             <<:

     

       389
       389
       +
               ttl: 3600

     

       390
       390
       +
               max_size: 1000

     

       391
       391
       +
             backend: memory

     

       392
       392
       +
         production:

     

       393
       393
       +
           database:

     

       394
       394
       +
             <<:

     

       395
       395
       +
               pool_size: 5

     

       396
       396
       +
               timeout: 30

     

       397
       397
       +
               ssl: false

     

       398
       398
       +
             host: prod.example.com

     

       399
       399
       +
             name: prod_db

     

       400
       400
       +
             ssl: true

     

       401
       401
       +
             pool_size: 20

     

       402
       402
       +
           cache:

     

       403
       403
       +
             <<:

     

       404
       404
       +
               ttl: 3600

     

       405
       405
       +
               max_size: 1000

     

       406
       406
       +
             backend: redis

     

       407
       407
       +
             ttl: 7200

+471

tests/cram/scalars.t

···

       1
       1
       +
       YAML Scalar Parsing Tests

     

       2
       2
       +
       

     

       3
       3
       +
       This file tests various forms of YAML scalar values including plain, quoted, and block scalars.

     

       4
       4
       +
       

     

       5
       5
       +
       ================================================================================

     

       6
       6
       +
       PLAIN SCALARS

     

       7
       7
       +
       ================================================================================

     

       8
       8
       +
       

     

       9
       9
       +
       Simple plain scalars

     

       10
       10
       +
       

     

       11
       11
       +
         $ echo 'key: value' | yamlcat

     

       12
       12
       +
         key: value

     

       13
       13
       +
       

     

       14
       14
       +
         $ echo 'name: Alice

     

       15
       15
       +
         > age: 30

     

       16
       16
       +
         > active: true' | yamlcat

     

       17
       17
       +
         name: Alice

     

       18
       18
       +
         age: 30

     

       19
       19
       +
         active: true

     

       20
       20
       +
       

     

       21
       21
       +
       Plain scalars with special values

     

       22
       22
       +
       

     

       23
       23
       +
         $ echo 'null_val: null

     

       24
       24
       +
         > bool_true: true

     

       25
       25
       +
         > bool_false: false

     

       26
       26
       +
         > number: 42

     

       27
       27
       +
         > float: 3.14' | yamlcat --json

     

       28
       28
       +
         {"null_val": null, "bool_true": true, "bool_false": false, "number": 42, "float": 3.14}

     

       29
       29
       +
       

     

       30
       30
       +
       ================================================================================

     

       31
       31
       +
       QUOTED SCALARS - SINGLE QUOTES

     

       32
       32
       +
       ================================================================================

     

       33
       33
       +
       

     

       34
       34
       +
       Single-quoted strings preserve literal text

     

       35
       35
       +
       

     

       36
       36
       +
         $ echo "single: 'hello world'" | yamlcat

     

       37
       37
       +
         single: hello world

     

       38
       38
       +
       

     

       39
       39
       +
       Single-quoted strings with embedded double quotes

     

       40
       40
       +
       

     

       41
       41
       +
         $ echo "quote: 'He said \"hello\"'" | yamlcat

     

       42
       42
       +
         quote: "He said \"hello\""

     

       43
       43
       +
       

     

       44
       44
       +
       Single-quoted strings with escaped single quotes (doubled)

     

       45
       45
       +
       

     

       46
       46
       +
         $ echo "escaped: 'It''s a test'" | yamlcat

     

       47
       47
       +
         escaped: It's a test

     

       48
       48
       +
       

     

       49
       49
       +
       Single-quoted multiline (newlines become spaces)

     

       50
       50
       +
       

     

       51
       51
       +
         $ echo "text: 'This is a

     

       52
       52
       +
         >   multi-line

     

       53
       53
       +
         >   string'" | yamlcat --json

     

       54
       54
       +
         {"text": "This is a multi-line string"}

     

       55
       55
       +
       

     

       56
       56
       +
       Empty single-quoted string

     

       57
       57
       +
       

     

       58
       58
       +
         $ echo "empty: ''" | yamlcat

     

       59
       59
       +
         empty: ''

     

       60
       60
       +
       

     

       61
       61
       +
       ================================================================================

     

       62
       62
       +
       QUOTED SCALARS - DOUBLE QUOTES

     

       63
       63
       +
       ================================================================================

     

       64
       64
       +
       

     

       65
       65
       +
       Simple double-quoted strings

     

       66
       66
       +
       

     

       67
       67
       +
         $ echo 'double: "hello world"' | yamlcat

     

       68
       68
       +
         double: hello world

     

       69
       69
       +
       

     

       70
       70
       +
       Double-quoted with escaped newline

     

       71
       71
       +
       

     

       72
       72
       +
         $ yamlcat --json escaped_newline.yml

     

       73
       73
       +
         {"text": "Line one\nLine two"}

     

       74
       74
       +
       

     

       75
       75
       +
       Double-quoted with escaped tab

     

       76
       76
       +
       

     

       77
       77
       +
         $ echo 'text: "Col1\tCol2\tCol3"' | yamlcat --json

     

       78
       78
       +
         {"text": "Col1\tCol2\tCol3"}

     

       79
       79
       +
       

     

       80
       80
       +
       Double-quoted with backslash escape

     

       81
       81
       +
       

     

       82
       82
       +
         $ echo 'path: "C:\\Users\\Name"' | yamlcat --json

     

       83
       83
       +
         Error: invalid hex escape:  at line 1, columns 12-12

     

       84
       84
       +
         [1]

     

       85
       85
       +
       

     

       86
       86
       +
       Double-quoted with escaped quote

     

       87
       87
       +
       

     

       88
       88
       +
         $ echo 'text: "She said \"hello\""' | yamlcat --json

     

       89
       89
       +
         {"text": "She said \"hello\""}

     

       90
       90
       +
       

     

       91
       91
       +
       Double-quoted with multiple escape sequences

     

       92
       92
       +
       

     

       93
       93
       +
         $ echo 'text: "Tab:\t Newline:\n Quote:\" Backslash:\\\\"' | yamlcat --json

     

       94
       94
       +
         {"text": "Tab:\t Newline: Quote:\" Backslash:\\"}

     

       95
       95
       +
       

     

       96
       96
       +
       Empty double-quoted string

     

       97
       97
       +
       

     

       98
       98
       +
         $ echo 'empty: ""' | yamlcat

     

       99
       99
       +
         empty: ''

     

       100
       100
       +
       

     

       101
       101
       +
       ================================================================================

     

       102
       102
       +
       BLOCK SCALARS - LITERAL STYLE (|)

     

       103
       103
       +
       ================================================================================

     

       104
       104
       +
       

     

       105
       105
       +
       Basic literal block scalar (preserves newlines)

     

       106
       106
       +
       

     

       107
       107
       +
         $ echo 'text: |

     

       108
       108
       +
         >   line one

     

       109
       109
       +
         >   line two

     

       110
       110
       +
         >   line three' | yamlcat --json

     

       111
       111
       +
         {"text": "line one\nline two\nline three\n"}

     

       112
       112
       +
       

     

       113
       113
       +
       Literal with indentation

     

       114
       114
       +
       

     

       115
       115
       +
         $ echo 'text: |

     

       116
       116
       +
         >   First line

     

       117
       117
       +
         >     Indented line

     

       118
       118
       +
         >   Back to first' | yamlcat --json

     

       119
       119
       +
         {"text": "First line\n  Indented line\nBack to first\n"}

     

       120
       120
       +
       

     

       121
       121
       +
       Literal with blank lines

     

       122
       122
       +
       

     

       123
       123
       +
         $ echo 'text: |

     

       124
       124
       +
         >   First paragraph

     

       125
       125
       +
         > 

     

       126
       126
       +
         >   Second paragraph' | yamlcat --json

     

       127
       127
       +
         {"text": "First paragraph\n\nSecond paragraph\n"}

     

       128
       128
       +
       

     

       129
       129
       +
       ================================================================================

     

       130
       130
       +
       BLOCK SCALARS - FOLDED STYLE (>)

     

       131
       131
       +
       ================================================================================

     

       132
       132
       +
       

     

       133
       133
       +
       Basic folded block scalar (newlines become spaces)

     

       134
       134
       +
       

     

       135
       135
       +
         $ echo 'text: >

     

       136
       136
       +
         >   This is a long paragraph

     

       137
       137
       +
         >   that will be folded into

     

       138
       138
       +
         >   a single line.' | yamlcat --json

     

       139
       139
       +
         {"text": "This is a long paragraph that will be folded into a single line.\n"}

     

       140
       140
       +
       

     

       141
       141
       +
       Folded with paragraph separation (blank line preserved)

     

       142
       142
       +
       

     

       143
       143
       +
         $ echo 'text: >

     

       144
       144
       +
         >   First paragraph

     

       145
       145
       +
         >   flows together.

     

       146
       146
       +
         > 

     

       147
       147
       +
         >   Second paragraph

     

       148
       148
       +
         >   also flows.' | yamlcat --json

     

       149
       149
       +
         {"text": "First paragraph flows together.\nSecond paragraph also flows.\n"}

     

       150
       150
       +
       

     

       151
       151
       +
       ================================================================================

     

       152
       152
       +
       CHOMPING INDICATORS

     

       153
       153
       +
       ================================================================================

     

       154
       154
       +
       

     

       155
       155
       +
       Strip chomping (-) removes trailing newlines

     

       156
       156
       +
       

     

       157
       157
       +
         $ echo 'text: |-

     

       158
       158
       +
         >   No trailing newline' | yamlcat --json

     

       159
       159
       +
         {"text": "No trailing newline"}

     

       160
       160
       +
       

     

       161
       161
       +
         $ echo 'text: |-

     

       162
       162
       +
         >   Text here

     

       163
       163
       +
         > 

     

       164
       164
       +
         > ' | yamlcat --json

     

       165
       165
       +
         {"text": "Text here"}

     

       166
       166
       +
       

     

       167
       167
       +
       Folded with strip

     

       168
       168
       +
       

     

       169
       169
       +
         $ echo 'text: >-

     

       170
       170
       +
         >   Folded text

     

       171
       171
       +
         >   with stripped

     

       172
       172
       +
         >   trailing newlines

     

       173
       173
       +
         > 

     

       174
       174
       +
         > ' | yamlcat --json

     

       175
       175
       +
         {"text": "Folded text with stripped trailing newlines"}

     

       176
       176
       +
       

     

       177
       177
       +
       Clip chomping (default) keeps single trailing newline

     

       178
       178
       +
       

     

       179
       179
       +
         $ echo 'text: |

     

       180
       180
       +
         >   One trailing newline

     

       181
       181
       +
         > 

     

       182
       182
       +
         > ' | yamlcat --json

     

       183
       183
       +
         {"text": "One trailing newline\n"}

     

       184
       184
       +
       

     

       185
       185
       +
         $ echo 'text: >

     

       186
       186
       +
         >   Folded with one

     

       187
       187
       +
         >   trailing newline

     

       188
       188
       +
         > 

     

       189
       189
       +
         > ' | yamlcat --json

     

       190
       190
       +
         {"text": "Folded with one trailing newline\n"}

     

       191
       191
       +
       

     

       192
       192
       +
       Keep chomping (+) preserves all trailing newlines

     

       193
       193
       +
       

     

       194
       194
       +
         $ echo 'text: |+

     

       195
       195
       +
         >   Keeps trailing newlines

     

       196
       196
       +
         > 

     

       197
       197
       +
         > 

     

       198
       198
       +
         > ' | yamlcat --json

     

       199
       199
       +
         {"text": "Keeps trailing newlines\n\n\n\n"}

     

       200
       200
       +
       

     

       201
       201
       +
         $ echo 'text: >+

     

       202
       202
       +
         >   Folded text

     

       203
       203
       +
         >   keeps trailing

     

       204
       204
       +
         > 

     

       205
       205
       +
         > 

     

       206
       206
       +
         > ' | yamlcat --json

     

       207
       207
       +
         {"text": "Folded text keeps trailing\n\n\n\n"}

     

       208
       208
       +
       

     

       209
       209
       +
       ================================================================================

     

       210
       210
       +
       EXPLICIT INDENTATION INDICATORS

     

       211
       211
       +
       ================================================================================

     

       212
       212
       +
       

     

       213
       213
       +
       Literal with explicit 2-space indentation

     

       214
       214
       +
       

     

       215
       215
       +
         $ echo 'text: |2

     

       216
       216
       +
         >     Two space base

     

       217
       217
       +
         >     Second line

     

       218
       218
       +
         >       Extra indent' | yamlcat --json

     

       219
       219
       +
         {"text": "  Two space base\n  Second line\n    Extra indent\n"}

     

       220
       220
       +
       

     

       221
       221
       +
       Folded with explicit indentation

     

       222
       222
       +
       

     

       223
       223
       +
         $ echo 'text: >2

     

       224
       224
       +
         >     Text with two space

     

       225
       225
       +
         >     base indentation that

     

       226
       226
       +
         >     will be folded.' | yamlcat --json

     

       227
       227
       +
         {"text": "  Text with two space\n  base indentation that\n  will be folded.\n"}

     

       228
       228
       +
       

     

       229
       229
       +
       Combined indentation and chomping indicators

     

       230
       230
       +
       

     

       231
       231
       +
         $ echo 'text: |2-

     

       232
       232
       +
         >     Indented by 2

     

       233
       233
       +
         >     No trailing newlines

     

       234
       234
       +
         > 

     

       235
       235
       +
         > ' | yamlcat --json

     

       236
       236
       +
         {"text": "  Indented by 2\n  No trailing newlines"}

     

       237
       237
       +
       

     

       238
       238
       +
         $ echo 'text: |2+

     

       239
       239
       +
         >     Indented by 2

     

       240
       240
       +
         >     Keeps trailing newlines

     

       241
       241
       +
         > 

     

       242
       242
       +
         > 

     

       243
       243
       +
         > ' | yamlcat --json

     

       244
       244
       +
         {"text": "  Indented by 2\n  Keeps trailing newlines\n\n\n\n"}

     

       245
       245
       +
       

     

       246
       246
       +
       ================================================================================

     

       247
       247
       +
       FILE TESTS - QUOTED SCALARS

     

       248
       248
       +
       ================================================================================

     

       249
       249
       +
       

     

       250
       250
       +
       Test parsing scalars_quoted.yml file

     

       251
       251
       +
       

     

       252
       252
       +
         $ yamlcat scalars_quoted.yml | head -20

     

       253
       253
       +
         single_simple: hello world

     

       254
       254
       +
         single_with_double: "He said \"hello\""

     

       255
       255
       +
         single_escaped_quote: 'It''s a single quote: ''example'''

     

       256
       256
       +
         single_multiline: This is a multi-line single quoted string

     

       257
       257
       +
         double_simple: hello world

     

       258
       258
       +
         double_with_single: It's easy

     

       259
       259
       +
         double_escaped_quote: "She said \"hello\""

     

       260
       260
       +
         escaped_newline: "Line one\nLine two\nLine three"

     

       261
       261
       +
         escaped_tab: "Column1\tColumn2\tColumn3"

     

       262
       262
       +
         escaped_backslash: "Path: C:\\Users\\Name"

     

       263
       263
       +
         escaped_carriage: "Before\rAfter"

     

       264
       264
       +
         escaped_bell: "Bell\x07"

     

       265
       265
       +
         escaped_backspace: "Back\x08"

     

       266
       266
       +
         escaped_formfeed: "Form\x0c"

     

       267
       267
       +
         escaped_vertical: "Vertical\x0btab"

     

       268
       268
       +
         unicode_16bit: 'Snowman: ☃'

     

       269
       269
       +
         unicode_32bit: 'Emoji: 😀'

     

       270
       270
       +
         unicode_hex: "Null byte: \x00"

     

       271
       271
       +
         empty_single: ''

     

       272
       272
       +
         empty_double: ''

     

       273
       273
       +
       

     

       274
       274
       +
       Test JSON output for quoted scalars

     

       275
       275
       +
       

     

       276
       276
       +
         $ yamlcat --json scalars_quoted.yml | head -c 500

     

       277
       277
       +
         {"single_simple": "hello world", "single_with_double": "He said \"hello\"", "single_escaped_quote": "It's a single quote: 'example'", "single_multiline": "This is a multi-line single quoted string", "double_simple": "hello world", "double_with_single": "It's easy", "double_escaped_quote": "She said \"hello\"", "escaped_newline": "Line one\nLine two\nLine three", "escaped_tab": "Column1\tColumn2\tColumn3", "escaped_backslash": "Path: C:\\Users\\Name", "escaped_carriage": "Before\rAfter", "escaped

     

       278
       278
       +
       

     

       279
       279
       +
       Verify specific escape handling in JSON

     

       280
       280
       +
       

     

       281
       281
       +
         $ yamlcat --json scalars_quoted.yml | grep -o '"escaped_newline": "[^"]*"'

     

       282
       282
       +
         "escaped_newline": "Line one\nLine two\nLine three"

     

       283
       283
       +
       

     

       284
       284
       +
         $ yamlcat --json scalars_quoted.yml | grep -o '"escaped_tab": "[^"]*"'

     

       285
       285
       +
         "escaped_tab": "Column1\tColumn2\tColumn3"

     

       286
       286
       +
       

     

       287
       287
       +
       Verify Unicode handling

     

       288
       288
       +
       

     

       289
       289
       +
         $ yamlcat --json scalars_quoted.yml | grep -o '"unicode_16bit": "[^"]*"'

     

       290
       290
       +
         "unicode_16bit": "Snowman: \226\152\131"

     

       291
       291
       +
       

     

       292
       292
       +
         $ yamlcat --json scalars_quoted.yml | grep -o '"unicode_32bit": "[^"]*"'

     

       293
       293
       +
         "unicode_32bit": "Emoji: \240\159\152\128"

     

       294
       294
       +
       

     

       295
       295
       +
       Verify quoted strings preserve type indicators

     

       296
       296
       +
       

     

       297
       297
       +
         $ yamlcat --json scalars_quoted.yml | grep -o '"string_true": "[^"]*"'

     

       298
       298
       +
         "string_true": "true"

     

       299
       299
       +
       

     

       300
       300
       +
         $ yamlcat --json scalars_quoted.yml | grep -o '"string_null": "[^"]*"'

     

       301
       301
       +
         "string_null": "null"

     

       302
       302
       +
       

     

       303
       303
       +
         $ yamlcat --json scalars_quoted.yml | grep -o '"string_number": "[^"]*"'

     

       304
       304
       +
         "string_number": "123"

     

       305
       305
       +
       

     

       306
       306
       +
       ================================================================================

     

       307
       307
       +
       FILE TESTS - BLOCK SCALARS

     

       308
       308
       +
       ================================================================================

     

       309
       309
       +
       

     

       310
       310
       +
       Test parsing scalars_block.yml file

     

       311
       311
       +
       

     

       312
       312
       +
         $ yamlcat scalars_block.yml | head -30

     

       313
       313
       +
         literal_basic: "Line one\nLine two\nLine three\n"

     

       314
       314
       +
         literal_with_indent: "First line\n  Indented line\n    More indented\n  Back to second level\nBack to first level\n"

     

       315
       315
       +
         folded_basic: "This is a long paragraph that will be folded into a single line with the newlines converted to spaces.\n"

     

       316
       316
       +
         folded_paragraph: "First paragraph flows together into a single line.\nSecond paragraph after blank line also flows together.\n"

     

       317
       317
       +
         literal_strip: No trailing newline

     

       318
       318
       +
         literal_strip_multiple: Text here

     

       319
       319
       +
         folded_strip: Folded text with stripped trailing newlines

     

       320
       320
       +
         literal_clip: "One trailing newline\n"

     

       321
       321
       +
         literal_clip_explicit: "This is the default behavior\n"

     

       322
       322
       +
         folded_clip: "Folded with one trailing newline\n"

     

       323
       323
       +
         literal_keep: "Keeps trailing newlines\n\n\n"

     

       324
       324
       +
         literal_keep_multiple: "Text here\n\n\n"

     

       325
       325
       +
         folded_keep: "Folded text keeps trailing\n\n\n"

     

       326
       326
       +
         literal_indent_2: "  Two space indentation\n  is preserved here\n    Extra indent\n  Back to two\n"

     

       327
       327
       +
         literal_indent_4: "  Four space base indent\n  Second line\n    Extra indent\n  Back to base\n"

     

       328
       328
       +
         folded_indent_2: "  Text with two space\n  base indentation that\n  will be folded.\n"

     

       329
       329
       +
         folded_indent_3: "  Three space indent\n  for this folded\n  text block.\n"

     

       330
       330
       +
         literal_indent_strip: "  Indented by 2\n  No trailing newlines"

     

       331
       331
       +
         folded_indent_strip: "  Folded with indent\n  and stripped end"

     

       332
       332
       +
         literal_indent_keep: "  Indented by 2\n  Keeps trailing newlines\n\n\n"

     

       333
       333
       +
         folded_indent_keep: "  Folded indent 4\n  keeps all trailing\n\n\n"

     

       334
       334
       +
         empty_literal: ''

     

       335
       335
       +
         empty_folded: ''

     

       336
       336
       +
         only_newlines_literal: ''

     

       337
       337
       +
         only_newlines_folded: ''

     

       338
       338
       +
         complex_literal: "First level\n  Second level\n    Third level\n  Back to second\nBack to first\n\nNew paragraph\n  With indent\n\nFinal paragraph\n"

     

       339
       339
       +
         complex_folded: "This paragraph flows together.\nThis is separate.\n  This line starts more indented\n  and continues.\n\nFinal thoughts here.\n"

     

       340
       340
       +
         special_chars_literal: "Special: @#$%^&*()\nQuotes: \"double\" 'single'\nBrackets: [array] {object}\nSymbols: | > & * ? : -\n"

     

       341
       341
       +
         special_chars_folded: "All special chars are literal in block scalars: []{}|>*&\n"

     

       342
       342
       +
         sequence_with_blocks:

     

       343
       343
       +
       

     

       344
       344
       +
       Test JSON output for block scalars

     

       345
       345
       +
       

     

       346
       346
       +
         $ yamlcat --json scalars_block.yml | grep -o '"literal_basic": "[^"]*"'

     

       347
       347
       +
         "literal_basic": "Line one\nLine two\nLine three\n"

     

       348
       348
       +
       

     

       349
       349
       +
         $ yamlcat --json scalars_block.yml | grep -o '"folded_basic": "[^"]*"' | head -c 100

     

       350
       350
       +
         "folded_basic": "This is a long paragraph that will be folded into a single line with the newlines c

     

       351
       351
       +
       

     

       352
       352
       +
       Verify strip chomping

     

       353
       353
       +
       

     

       354
       354
       +
         $ yamlcat --json scalars_block.yml | grep -o '"literal_strip": "[^"]*"'

     

       355
       355
       +
         "literal_strip": "No trailing newline"

     

       356
       356
       +
       

     

       357
       357
       +
         $ yamlcat --json scalars_block.yml | grep -o '"folded_strip": "[^"]*"'

     

       358
       358
       +
         "folded_strip": "Folded text with stripped trailing newlines"

     

       359
       359
       +
       

     

       360
       360
       +
       Verify clip chomping (single newline)

     

       361
       361
       +
       

     

       362
       362
       +
         $ yamlcat --json scalars_block.yml | grep -o '"literal_clip": "[^"]*"'

     

       363
       363
       +
         "literal_clip": "One trailing newline\n"

     

       364
       364
       +
       

     

       365
       365
       +
       Verify keep chomping (all newlines)

     

       366
       366
       +
       

     

       367
       367
       +
         $ yamlcat --json scalars_block.yml | grep -o '"literal_keep": "[^"]*"'

     

       368
       368
       +
         "literal_keep": "Keeps trailing newlines\n\n\n"

     

       369
       369
       +
       

     

       370
       370
       +
         $ yamlcat --json scalars_block.yml | grep -o '"folded_keep": "[^"]*"'

     

       371
       371
       +
         "folded_keep": "Folded text keeps trailing\n\n\n"

     

       372
       372
       +
       

     

       373
       373
       +
       Verify indentation handling

     

       374
       374
       +
       

     

       375
       375
       +
         $ yamlcat --json scalars_block.yml | grep -o '"literal_indent_2": "[^"]*"'

     

       376
       376
       +
         "literal_indent_2": "  Two space indentation\n  is preserved here\n    Extra indent\n  Back to two\n"

     

       377
       377
       +
       

     

       378
       378
       +
       Verify nested structures with block scalars

     

       379
       379
       +
       

     

       380
       380
       +
         $ yamlcat scalars_block.yml | tail -10

     

       381
       381
       +
         special_chars_folded: "All special chars are literal in block scalars: []{}|>*&\n"

     

       382
       382
       +
         sequence_with_blocks:

     

       383
       383
       +
           - "First item\nliteral block\n"

     

       384
       384
       +
           - "Second item folded block\n"

     

       385
       385
       +
           - "Third item\nstripped"

     

       386
       386
       +
           - "Fourth item\nkept\n\n\n"

     

       387
       387
       +
         nested:

     

       388
       388
       +
           description: "This is a folded description that spans multiple lines.\n"

     

       389
       389
       +
           code: "def hello():\n    print(\"Hello, World!\")\n    return True\n"

     

       390
       390
       +
           notes: "Final notes\nwith stripped end"

     

       391
       391
       +
       

     

       392
       392
       +
       ================================================================================

     

       393
       393
       +
       SPECIAL CASES AND EDGE CASES

     

       394
       394
       +
       ================================================================================

     

       395
       395
       +
       

     

       396
       396
       +
       Empty block scalars

     

       397
       397
       +
       

     

       398
       398
       +
         $ echo 'empty_literal: |' | yamlcat --json

     

       399
       399
       +
         {"empty_literal": ""}

     

       400
       400
       +
       

     

       401
       401
       +
         $ echo 'empty_folded: >' | yamlcat --json

     

       402
       402
       +
         {"empty_folded": ""}

     

       403
       403
       +
       

     

       404
       404
       +
       Block scalars with special characters (no escaping needed)

     

       405
       405
       +
       

     

       406
       406
       +
         $ echo 'code: |

     

       407
       407
       +
         >   Special: @#$%^&*()

     

       408
       408
       +
         >   Quotes: "double" '"'"'single'"'"'

     

       409
       409
       +
         >   Brackets: [array] {object}' | yamlcat --json

     

       410
       410
       +
         {"code": "Special: @#$%^&*()\nQuotes: \"double\" 'single'\nBrackets: [array] {object}\n"}

     

       411
       411
       +
       

     

       412
       412
       +
       Plain scalar vs quoted string for special values

     

       413
       413
       +
       

     

       414
       414
       +
         $ echo 'unquoted_true: true

     

       415
       415
       +
         > quoted_true: "true"' | yamlcat --json

     

       416
       416
       +
         {"unquoted_true": true, "quoted_true": "true"}

     

       417
       417
       +
       

     

       418
       418
       +
         $ echo 'unquoted_null: null

     

       419
       419
       +
         > quoted_null: "null"' | yamlcat --json

     

       420
       420
       +
         {"unquoted_null": null, "quoted_null": "null"}

     

       421
       421
       +
       

     

       422
       422
       +
       Strings that need quoting to preserve leading/trailing spaces

     

       423
       423
       +
       

     

       424
       424
       +
         $ echo 'leading: "  spaces"

     

       425
       425
       +
         > trailing: "spaces  "

     

       426
       426
       +
         > both: "  spaces  "' | yamlcat --json

     

       427
       427
       +
         {"leading": "  spaces", "trailing": "spaces  ", "both": "  spaces  "}

     

       428
       428
       +
       

     

       429
       429
       +
       Block scalars in sequences

     

       430
       430
       +
       

     

       431
       431
       +
         $ echo 'items:

     

       432
       432
       +
         >   - |

     

       433
       433
       +
         >     First item

     

       434
       434
       +
         >     multiline

     

       435
       435
       +
         >   - >

     

       436
       436
       +
         >     Second item

     

       437
       437
       +
         >     folded' | yamlcat --json

     

       438
       438
       +
         {"items": ["First item\nmultiline\n", "Second item folded\n"]}

     

       439
       439
       +
       

     

       440
       440
       +
       Block scalars in nested mappings

     

       441
       441
       +
       

     

       442
       442
       +
         $ echo 'outer:

     

       443
       443
       +
         >   inner:

     

       444
       444
       +
         >     description: >

     

       445
       445
       +
         >       This is a folded

     

       446
       446
       +
         >       description.

     

       447
       447
       +
         >     code: |

     

       448
       448
       +
         >       def test():

     

       449
       449
       +
         >           return True' | yamlcat --json

     

       450
       450
       +
         {"outer": {"inner": {"description": "This is a folded description.\n", "code": "def test():\n    return True\n"}}}

     

       451
       451
       +
       

     

       452
       452
       +
       Preserving indentation in literal blocks

     

       453
       453
       +
       

     

       454
       454
       +
         $ echo 'code: |

     

       455
       455
       +
         >   def hello():

     

       456
       456
       +
         >       print("Hello")

     

       457
       457
       +
         >       if True:

     

       458
       458
       +
         >           return 42' | yamlcat --json

     

       459
       459
       +
         {"code": "def hello():\n    print(\"Hello\")\n    if True:\n        return 42\n"}

     

       460
       460
       +
       

     

       461
       461
       +
       Folded scalars preserve more-indented lines

     

       462
       462
       +
       

     

       463
       463
       +
         $ echo 'text: >

     

       464
       464
       +
         >   Normal paragraph

     

       465
       465
       +
         >   continues here.

     

       466
       466
       +
         > 

     

       467
       467
       +
         >     Indented block

     

       468
       468
       +
         >     preserved.

     

       469
       469
       +
         > 

     

       470
       470
       +
         >   Back to normal.' | yamlcat --json

     

       471
       471
       +
         {"text": "Normal paragraph continues here.\n\n  Indented block\n  preserved.\n\nBack to normal.\n"}

+192

tests/cram/scalars_block.yml

···

       1
       1
       +
       # Block scalars - literal and folded styles

     

       2
       2
       +
       ---

     

       3
       3
       +
       # Literal style (|) - preserves newlines

     

       4
       4
       +
       literal_basic: |

     

       5
       5
       +
         Line one

     

       6
       6
       +
         Line two

     

       7
       7
       +
         Line three

     

       8
       8
       +
       

     

       9
       9
       +
       literal_with_indent: |

     

       10
       10
       +
         First line

     

       11
       11
       +
           Indented line

     

       12
       12
       +
             More indented

     

       13
       13
       +
           Back to second level

     

       14
       14
       +
         Back to first level

     

       15
       15
       +
       

     

       16
       16
       +
       # Folded style (>) - converts newlines to spaces

     

       17
       17
       +
       folded_basic: >

     

       18
       18
       +
         This is a long paragraph

     

       19
       19
       +
         that will be folded into

     

       20
       20
       +
         a single line with the

     

       21
       21
       +
         newlines converted to spaces.

     

       22
       22
       +
       

     

       23
       23
       +
       folded_paragraph: >

     

       24
       24
       +
         First paragraph flows together

     

       25
       25
       +
         into a single line.

     

       26
       26
       +
       

     

       27
       27
       +
         Second paragraph after blank line

     

       28
       28
       +
         also flows together.

     

       29
       29
       +
       

     

       30
       30
       +
       # Chomping indicators

     

       31
       31
       +
       # Strip (-) - removes trailing newlines

     

       32
       32
       +
       literal_strip: |-

     

       33
       33
       +
         No trailing newline

     

       34
       34
       +
       

     

       35
       35
       +
       

     

       36
       36
       +
       literal_strip_multiple: |-

     

       37
       37
       +
         Text here

     

       38
       38
       +
       

     

       39
       39
       +
       

     

       40
       40
       +
       folded_strip: >-

     

       41
       41
       +
         Folded text

     

       42
       42
       +
         with stripped

     

       43
       43
       +
         trailing newlines

     

       44
       44
       +
       

     

       45
       45
       +
       

     

       46
       46
       +
       # Clip (default) - keeps single trailing newline

     

       47
       47
       +
       literal_clip: |

     

       48
       48
       +
         One trailing newline

     

       49
       49
       +
       

     

       50
       50
       +
       

     

       51
       51
       +
       literal_clip_explicit: |

     

       52
       52
       +
         This is the default behavior

     

       53
       53
       +
       

     

       54
       54
       +
       

     

       55
       55
       +
       folded_clip: >

     

       56
       56
       +
         Folded with one

     

       57
       57
       +
         trailing newline

     

       58
       58
       +
       

     

       59
       59
       +
       

     

       60
       60
       +
       # Keep (+) - preserves all trailing newlines

     

       61
       61
       +
       literal_keep: |+

     

       62
       62
       +
         Keeps trailing newlines

     

       63
       63
       +
       

     

       64
       64
       +
       

     

       65
       65
       +
       literal_keep_multiple: |+

     

       66
       66
       +
         Text here

     

       67
       67
       +
       

     

       68
       68
       +
       

     

       69
       69
       +
       folded_keep: >+

     

       70
       70
       +
         Folded text

     

       71
       71
       +
         keeps trailing

     

       72
       72
       +
       

     

       73
       73
       +
       

     

       74
       74
       +
       # Explicit indentation indicators

     

       75
       75
       +
       literal_indent_2: |2

     

       76
       76
       +
           Two space indentation

     

       77
       77
       +
           is preserved here

     

       78
       78
       +
             Extra indent

     

       79
       79
       +
           Back to two

     

       80
       80
       +
       

     

       81
       81
       +
       literal_indent_4: |4

     

       82
       82
       +
             Four space base indent

     

       83
       83
       +
             Second line

     

       84
       84
       +
               Extra indent

     

       85
       85
       +
             Back to base

     

       86
       86
       +
       

     

       87
       87
       +
       folded_indent_2: >2

     

       88
       88
       +
           Text with two space

     

       89
       89
       +
           base indentation that

     

       90
       90
       +
           will be folded.

     

       91
       91
       +
       

     

       92
       92
       +
       folded_indent_3: >3

     

       93
       93
       +
            Three space indent

     

       94
       94
       +
            for this folded

     

       95
       95
       +
            text block.

     

       96
       96
       +
       

     

       97
       97
       +
       # Combinations of indicators

     

       98
       98
       +
       literal_indent_strip: |2-

     

       99
       99
       +
           Indented by 2

     

       100
       100
       +
           No trailing newlines

     

       101
       101
       +
       

     

       102
       102
       +
       

     

       103
       103
       +
       folded_indent_strip: >3-

     

       104
       104
       +
            Folded with indent

     

       105
       105
       +
            and stripped end

     

       106
       106
       +
       

     

       107
       107
       +
       

     

       108
       108
       +
       literal_indent_keep: |2+

     

       109
       109
       +
           Indented by 2

     

       110
       110
       +
           Keeps trailing newlines

     

       111
       111
       +
       

     

       112
       112
       +
       

     

       113
       113
       +
       folded_indent_keep: >4+

     

       114
       114
       +
             Folded indent 4

     

       115
       115
       +
             keeps all trailing

     

       116
       116
       +
       

     

       117
       117
       +
       

     

       118
       118
       +
       # Empty block scalars

     

       119
       119
       +
       empty_literal: |

     

       120
       120
       +
       

     

       121
       121
       +
       empty_folded: >

     

       122
       122
       +
       

     

       123
       123
       +
       # Block scalar with only newlines

     

       124
       124
       +
       only_newlines_literal: |

     

       125
       125
       +
       

     

       126
       126
       +
       

     

       127
       127
       +
       only_newlines_folded: >

     

       128
       128
       +
       

     

       129
       129
       +
       

     

       130
       130
       +
       # Complex indentation patterns

     

       131
       131
       +
       complex_literal: |

     

       132
       132
       +
         First level

     

       133
       133
       +
           Second level

     

       134
       134
       +
             Third level

     

       135
       135
       +
           Back to second

     

       136
       136
       +
         Back to first

     

       137
       137
       +
       

     

       138
       138
       +
         New paragraph

     

       139
       139
       +
           With indent

     

       140
       140
       +
       

     

       141
       141
       +
         Final paragraph

     

       142
       142
       +
       

     

       143
       143
       +
       complex_folded: >

     

       144
       144
       +
         This paragraph

     

       145
       145
       +
         flows together.

     

       146
       146
       +
       

     

       147
       147
       +
         This is separate.

     

       148
       148
       +
           This line starts more indented

     

       149
       149
       +
           and continues.

     

       150
       150
       +
       

     

       151
       151
       +
         Final thoughts here.

     

       152
       152
       +
       

     

       153
       153
       +
       # Special characters in block scalars

     

       154
       154
       +
       special_chars_literal: |

     

       155
       155
       +
         Special: @#$%^&*()

     

       156
       156
       +
         Quotes: "double" 'single'

     

       157
       157
       +
         Brackets: [array] {object}

     

       158
       158
       +
         Symbols: | > & * ? : -

     

       159
       159
       +
       

     

       160
       160
       +
       special_chars_folded: >

     

       161
       161
       +
         All special chars are literal

     

       162
       162
       +
         in block scalars: []{}|>*&

     

       163
       163
       +
       

     

       164
       164
       +
       # Block scalars in sequences

     

       165
       165
       +
       sequence_with_blocks:

     

       166
       166
       +
         - |

     

       167
       167
       +
           First item

     

       168
       168
       +
           literal block

     

       169
       169
       +
         - >

     

       170
       170
       +
           Second item

     

       171
       171
       +
           folded block

     

       172
       172
       +
         - |-

     

       173
       173
       +
           Third item

     

       174
       174
       +
           stripped

     

       175
       175
       +
         - |+

     

       176
       176
       +
           Fourth item

     

       177
       177
       +
           kept

     

       178
       178
       +
       

     

       179
       179
       +
       

     

       180
       180
       +
       # Block scalars in nested mappings

     

       181
       181
       +
       nested:

     

       182
       182
       +
         description: >

     

       183
       183
       +
           This is a folded

     

       184
       184
       +
           description that spans

     

       185
       185
       +
           multiple lines.

     

       186
       186
       +
         code: |

     

       187
       187
       +
           def hello():

     

       188
       188
       +
               print("Hello, World!")

     

       189
       189
       +
               return True

     

       190
       190
       +
         notes: |-

     

       191
       191
       +
           Final notes

     

       192
       192
       +
           with stripped end

+60

tests/cram/scalars_plain.yml

···

       1
       1
       +
       # Plain scalars - no quotes needed

     

       2
       2
       +
       ---

     

       3
       3
       +
       # Simple words

     

       4
       4
       +
       simple_word: hello

     

       5
       5
       +
       single_character: x

     

       6
       6
       +
       number_like: 123

     

       7
       7
       +
       boolean_like: true

     

       8
       8
       +
       null_like: null

     

       9
       9
       +
       

     

       10
       10
       +
       # Multi-word values (no special meaning characters)

     

       11
       11
       +
       sentence: this is a plain scalar

     

       12
       12
       +
       phrase: plain scalars can have spaces

     

       13
       13
       +
       

     

       14
       14
       +
       # Numbers and special values that remain strings in context

     

       15
       15
       +
       age: 42

     

       16
       16
       +
       pi: 3.14159

     

       17
       17
       +
       negative: -273

     

       18
       18
       +
       scientific: 1.23e-4

     

       19
       19
       +
       hex_like: 0x1A2B

     

       20
       20
       +
       octal_like: 0o755

     

       21
       21
       +
       

     

       22
       22
       +
       # Special characters that are valid in plain scalars

     

       23
       23
       +
       with_colon: "value: with colon needs quotes in value"

     

       24
       24
       +
       with_comma: "commas, need quotes in flow context"

     

       25
       25
       +
       with_hash: "# needs quotes if starting with hash"

     

       26
       26
       +
       hyphen_start: "- needs quotes if starting like list"

     

       27
       27
       +
       question_start: "? needs quotes if starting like mapping key"

     

       28
       28
       +
       

     

       29
       29
       +
       # Plain scalars with valid special characters

     

       30
       30
       +
       email: user@example.com

     

       31
       31
       +
       url: http://example.com/path

     

       32
       32
       +
       path: /usr/local/bin

     

       33
       33
       +
       ratio: 16:9

     

       34
       34
       +
       version: v1.2.3

     

       35
       35
       +
       

     

       36
       36
       +
       # Multi-line plain scalars (line folding)

     

       37
       37
       +
       # Newlines become spaces, blank lines become newlines

     

       38
       38
       +
       folded_plain: This is a long

     

       39
       39
       +
         plain scalar that spans

     

       40
       40
       +
         multiple lines and will

     

       41
       41
       +
         be folded into a single line

     

       42
       42
       +
         with spaces.

     

       43
       43
       +
       

     

       44
       44
       +
       another_folded: First paragraph

     

       45
       45
       +
         continues here and here.

     

       46
       46
       +
       

     

       47
       47
       +
         Second paragraph after blank line.

     

       48
       48
       +
         Also continues.

     

       49
       49
       +
       

     

       50
       50
       +
       # Trailing and leading spaces are trimmed in plain scalars

     

       51
       51
       +
       spaces_trimmed:   value with spaces

     

       52
       52
       +
       

     

       53
       53
       +
       # Plain scalars can contain most punctuation

     

       54
       54
       +
       punctuation: Hello, world! How are you? I'm fine.

     

       55
       55
       +
       symbols: $100 & 50% off @ store #1

     

       56
       56
       +
       math: 2+2=4 and 3*3=9

     

       57
       57
       +
       

     

       58
       58
       +
       # Empty plain scalar (becomes null)

     

       59
       59
       +
       empty_implicit:

     

       60
       60
       +
       explicit_empty: ""

+81

tests/cram/scalars_quoted.yml

···

       1
       1
       +
       # Quoted scalars - single and double quoted strings

     

       2
       2
       +
       ---

     

       3
       3
       +
       # Single-quoted strings

     

       4
       4
       +
       single_simple: 'hello world'

     

       5
       5
       +
       single_with_double: 'He said "hello"'

     

       6
       6
       +
       single_escaped_quote: 'It''s a single quote: ''example'''

     

       7
       7
       +
       single_multiline: 'This is a

     

       8
       8
       +
         multi-line single

     

       9
       9
       +
         quoted string'

     

       10
       10
       +
       

     

       11
       11
       +
       # Double-quoted strings

     

       12
       12
       +
       double_simple: "hello world"

     

       13
       13
       +
       double_with_single: "It's easy"

     

       14
       14
       +
       double_escaped_quote: "She said \"hello\""

     

       15
       15
       +
       

     

       16
       16
       +
       # Escape sequences in double-quoted strings

     

       17
       17
       +
       escaped_newline: "Line one\nLine two\nLine three"

     

       18
       18
       +
       escaped_tab: "Column1\tColumn2\tColumn3"

     

       19
       19
       +
       escaped_backslash: "Path: C:\\Users\\Name"

     

       20
       20
       +
       escaped_carriage: "Before\rAfter"

     

       21
       21
       +
       escaped_bell: "Bell\a"

     

       22
       22
       +
       escaped_backspace: "Back\b"

     

       23
       23
       +
       escaped_formfeed: "Form\f"

     

       24
       24
       +
       escaped_vertical: "Vertical\vtab"

     

       25
       25
       +
       

     

       26
       26
       +
       # Unicode escapes

     

       27
       27
       +
       unicode_16bit: "Snowman: \u2603"

     

       28
       28
       +
       unicode_32bit: "Emoji: \U0001F600"

     

       29
       29
       +
       unicode_hex: "Null byte: \x00"

     

       30
       30
       +
       

     

       31
       31
       +
       # Empty strings

     

       32
       32
       +
       empty_single: ''

     

       33
       33
       +
       empty_double: ""

     

       34
       34
       +
       

     

       35
       35
       +
       # Strings that would be interpreted as other types if unquoted

     

       36
       36
       +
       string_true: "true"

     

       37
       37
       +
       string_false: "false"

     

       38
       38
       +
       string_null: "null"

     

       39
       39
       +
       string_number: "123"

     

       40
       40
       +
       string_float: "45.67"

     

       41
       41
       +
       string_octal: "0o755"

     

       42
       42
       +
       string_hex: "0xFF"

     

       43
       43
       +
       

     

       44
       44
       +
       # Special YAML characters that need quoting

     

       45
       45
       +
       starts_with_at: "@username"

     

       46
       46
       +
       starts_with_backtick: "`command`"

     

       47
       47
       +
       starts_with_ampersand: "&reference"

     

       48
       48
       +
       starts_with_asterisk: "*alias"

     

       49
       49
       +
       starts_with_exclamation: "!tag"

     

       50
       50
       +
       starts_with_pipe: "|literal"

     

       51
       51
       +
       starts_with_gt: ">folded"

     

       52
       52
       +
       starts_with_percent: "%directive"

     

       53
       53
       +
       

     

       54
       54
       +
       # Flow indicators that need quoting

     

       55
       55
       +
       with_brackets: "[not a list]"

     

       56
       56
       +
       with_braces: "{not: a map}"

     

       57
       57
       +
       with_comma: "a, b, c"

     

       58
       58
       +
       with_colon_space: "key: value"

     

       59
       59
       +
       

     

       60
       60
       +
       # Quoted strings preserve leading/trailing whitespace

     

       61
       61
       +
       leading_space: "  spaces before"

     

       62
       62
       +
       trailing_space: "spaces after  "

     

       63
       63
       +
       both_spaces: "  spaces both  "

     

       64
       64
       +
       

     

       65
       65
       +
       # Multi-line quoted strings

     

       66
       66
       +
       double_multiline: "This is a string

     

       67
       67
       +
         that spans multiple

     

       68
       68
       +
         lines with escaped newlines."

     

       69
       69
       +
       

     

       70
       70
       +
       single_fold: 'This single quoted

     

       71
       71
       +
         string will fold

     

       72
       72
       +
         lines into spaces.'

     

       73
       73
       +
       

     

       74
       74
       +
       # Complex escape sequences

     

       75
       75
       +
       complex_escapes: "Tab:\t Newline:\n Quote:\" Backslash:\\ Unicode:\u0041"

     

       76
       76
       +
       

     

       77
       77
       +
       # Edge cases

     

       78
       78
       +
       only_spaces_single: '   '

     

       79
       79
       +
       only_spaces_double: "   "

     

       80
       80
       +
       only_newlines: "\n\n\n"

     

       81
       81
       +
       mixed_quotes: "She said 'it''s a beautiful day'"

tests/cram/seq.yml

tests/cram/simple_alias.yml

···

       1
       1
       +
       anchor: &anc hello

     

       2
       2
       +
       alias: *anc

+60

tests/cram/tags.t

···

       1
       1
       +
       Tag Support Tests

     

       2
       2
       +
       

     

       3
       3
       +
       These tests verify YAML tag support including type coercion and

     

       4
       4
       +
       different tag formats.

     

       5
       5
       +
       

     

       6
       6
       +
       Test: String tag shorthand

     

       7
       7
       +
       

     

       8
       8
       +
         $ printf '!!str 123' | yamlcat

     

       9
       9
       +
         '123'

     

       10
       10
       +
       

     

       11
       11
       +
       The !!str tag forces the value to be treated as a string.

     

       12
       12
       +
       

     

       13
       13
       +
       Test: Integer tag shorthand

     

       14
       14
       +
       

     

       15
       15
       +
         $ printf '!!int "42"' | yamlcat

     

       16
       16
       +
         42

     

       17
       17
       +
       

     

       18
       18
       +
       The !!int tag coerces the quoted string to an integer.

     

       19
       19
       +
       

     

       20
       20
       +
       Test: Boolean tag shorthand

     

       21
       21
       +
       

     

       22
       22
       +
         $ printf '!!bool "yes"' | yamlcat

     

       23
       23
       +
         true

     

       24
       24
       +
       

     

       25
       25
       +
       The !!bool tag coerces the string to a boolean.

     

       26
       26
       +
       

     

       27
       27
       +
       Test: Null tag shorthand

     

       28
       28
       +
       

     

       29
       29
       +
         $ printf '!!null ""' | yamlcat

     

       30
       30
       +
         null

     

       31
       31
       +
       

     

       32
       32
       +
       The !!null tag coerces the value to null.

     

       33
       33
       +
       

     

       34
       34
       +
       Test: Float tag shorthand

     

       35
       35
       +
       

     

       36
       36
       +
         $ printf '!!float 3.14' | yamlcat

     

       37
       37
       +
         3.14

     

       38
       38
       +
       

     

       39
       39
       +
       The !!float tag specifies a floating-point number.

     

       40
       40
       +
       

     

       41
       41
       +
       Test: Tag shorthand in mapping value

     

       42
       42
       +
       

     

       43
       43
       +
         $ printf 'value: !!str 42' | yamlcat

     

       44
       44
       +
         value: '42'

     

       45
       45
       +
       

     

       46
       46
       +
       Tags work in mapping values and force type coercion.

     

       47
       47
       +
       

     

       48
       48
       +
       Test: Local tags

     

       49
       49
       +
       

     

       50
       50
       +
         $ printf '!local_tag value' | yamlcat

     

       51
       51
       +
         value

     

       52
       52
       +
       

     

       53
       53
       +
       Local tags (single !) are treated as unknown and default to string type.

     

       54
       54
       +
       

     

       55
       55
       +
       Test: Verbatim tags

     

       56
       56
       +
       

     

       57
       57
       +
         $ printf '!<tag:example.com:type> value' | yamlcat

     

       58
       58
       +
         value

     

       59
       59
       +
       

     

       60
       60
       +
       Verbatim tags (!<...>) are treated as unknown and default to string type.

tests/cram/valid_alias.yml

···

       1
       1
       +
       defaults: &defaults

     

       2
       2
       +
         timeout: 30

     

       3
       3
       +
         retries: 3

     

       4
       4
       +
       production:

     

       5
       5
       +
         <<: *defaults

     

       6
       6
       +
         port: 8080

+85

tests/cram/valid_floats.t

···

       1
       1
       +
       Test valid YAML float number formats

     

       2
       2
       +
       

     

       3
       3
       +
       This tests various real-world ways to write floating point numbers in YAML:

     

       4
       4
       +
       - Basic decimal notation (3.14, -0.5)

     

       5
       5
       +
       - Leading dot notation (.5 for 0.5)

     

       6
       6
       +
       - Scientific notation (1e10, 1E-10, 1.5e+10)

     

       7
       7
       +
       - Positive/negative signs

     

       8
       8
       +
       - Edge cases (very large, very small, negative zero)

     

       9
       9
       +
       

     

       10
       10
       +
         $ yamlcat valid_floats.yml

     

       11
       11
       +
         basic_positive: 3.14

     

       12
       12
       +
         basic_negative: -3.14

     

       13
       13
       +
         basic_zero: 0

     

       14
       14
       +
         small_positive: 0.5

     

       15
       15
       +
         small_negative: -0.5

     

       16
       16
       +
         leading_dot: 0.5

     

       17
       17
       +
         leading_dot_negative: -0.5

     

       18
       18
       +
         leading_dot_positive: 0.5

     

       19
       19
       +
         leading_dot_long: 0.123457

     

       20
       20
       +
         trailing_zero: 1

     

       21
       21
       +
         trailing_zeros: 1

     

       22
       22
       +
         many_trailing: 3.14

     

       23
       23
       +
         sci_positive: 10000000000

     

       24
       24
       +
         sci_negative: 1e-10

     

       25
       25
       +
         sci_explicit_positive: 10000000000

     

       26
       26
       +
         sci_with_decimal: 15000000000

     

       27
       27
       +
         sci_small: 6.022e+23

     

       28
       28
       +
         sci_tiny: 1.6e-19

     

       29
       29
       +
         sci_upper: 10000000000

     

       30
       30
       +
         sci_upper_negative: 1e-10

     

       31
       31
       +
         sci_upper_explicit: 10000000000

     

       32
       32
       +
         sci_upper_decimal: 250000000

     

       33
       33
       +
         neg_sci: -10000000000

     

       34
       34
       +
         neg_sci_negative_exp: -1e-10

     

       35
       35
       +
         neg_sci_decimal: -314000

     

       36
       36
       +
         positive_sign: 3.14

     

       37
       37
       +
         positive_sci: 10000000000

     

       38
       38
       +
         positive_small: 0.001

     

       39
       39
       +
         very_large: 1e+100

     

       40
       40
       +
         very_small: 1e-100

     

       41
       41
       +
         large_decimal: 1e+09

     

       42
       42
       +
         small_decimal: 1e-09

     

       43
       43
       +
         negative_zero: -0

     

       44
       44
       +
         positive_zero: 0

     

       45
       45
       +
         one: 1

     

       46
       46
       +
         minus_one: -1

     

       47
       47
       +
         pi: 3.14159

     

       48
       48
       +
         euler: 2.71828

     

       49
       49
       +
         golden_ratio: 1.61803

     

       50
       50
       +
         planck: 6.62607e-34

     

       51
       51
       +
         avogadro: 6.02214e+23

     

       52
       52
       +
         speed_of_light: 299792458

     

       53
       53
       +
         gravitational_constant: 6.674e-11

     

       54
       54
       +
         coordinates:

     

       55
       55
       +
           latitude: 37.7749

     

       56
       56
       +
           longitude: -122.419

     

       57
       57
       +
           altitude: 16

     

       58
       58
       +
         prices:

     

       59
       59
       +
           item1: 19.99

     

       60
       60
       +
           item2: 0.99

     

       61
       61
       +
           discount: -5

     

       62
       62
       +
           tax_rate: 0.0825

     

       63
       63
       +
         measurements:

     

       64
       64
       +
           temperature_c: 23.5

     

       65
       65
       +
           temperature_f: 74.3

     

       66
       66
       +
           humidity: 0.65

     

       67
       67
       +
           pressure_hpa: 1013.25

     

       68
       68
       +
         float_sequence:

     

       69
       69
       +
           - 1

     

       70
       70
       +
           - -1

     

       71
       71
       +
           - 0.5

     

       72
       72
       +
           - -0.5

     

       73
       73
       +
           - 10000000000

     

       74
       74
       +
           - 1e-10

     

       75
       75
       +
           - 0.5

     

       76
       76
       +
           - -0.5

     

       77
       77
       +
         integers:

     

       78
       78
       +
           simple: 42

     

       79
       79
       +
           negative: -17

     

       80
       80
       +
           zero: 0

     

       81
       81
       +
           hex: 26

     

       82
       82
       +
           octal: 12

     

       83
       83
       +
       

     

       84
       84
       +
         $ yamlcat --json valid_floats.yml

     

       85
       85
       +
         {"basic_positive": 3.14, "basic_negative": -3.14, "basic_zero": 0, "small_positive": 0.5, "small_negative": -0.5, "leading_dot": 0.5, "leading_dot_negative": -0.5, "leading_dot_positive": 0.5, "leading_dot_long": 0.123457, "trailing_zero": 1, "trailing_zeros": 1, "many_trailing": 3.14, "sci_positive": 10000000000, "sci_negative": 1e-10, "sci_explicit_positive": 10000000000, "sci_with_decimal": 15000000000, "sci_small": 6.022e+23, "sci_tiny": 1.6e-19, "sci_upper": 10000000000, "sci_upper_negative": 1e-10, "sci_upper_explicit": 10000000000, "sci_upper_decimal": 250000000, "neg_sci": -10000000000, "neg_sci_negative_exp": -1e-10, "neg_sci_decimal": -314000, "positive_sign": 3.14, "positive_sci": 10000000000, "positive_small": 0.001, "very_large": 1e+100, "very_small": 1e-100, "large_decimal": 1e+09, "small_decimal": 1e-09, "negative_zero": -0, "positive_zero": 0, "one": 1, "minus_one": -1, "pi": 3.14159, "euler": 2.71828, "golden_ratio": 1.61803, "planck": 6.62607e-34, "avogadro": 6.02214e+23, "speed_of_light": 299792458, "gravitational_constant": 6.674e-11, "coordinates": {"latitude": 37.7749, "longitude": -122.419, "altitude": 16}, "prices": {"item1": 19.99, "item2": 0.99, "discount": -5, "tax_rate": 0.0825}, "measurements": {"temperature_c": 23.5, "temperature_f": 74.3, "humidity": 0.65, "pressure_hpa": 1013.25}, "float_sequence": [1, -1, 0.5, -0.5, 10000000000, 1e-10, 0.5, -0.5], "integers": {"simple": 42, "negative": -17, "zero": 0, "hex": 26, "octal": 12}}

+103

tests/cram/valid_floats.yml

···

       1
       1
       +
       # Test valid YAML float number formats

     

       2
       2
       +
       

     

       3
       3
       +
       # Basic decimal floats

     

       4
       4
       +
       basic_positive: 3.14

     

       5
       5
       +
       basic_negative: -3.14

     

       6
       6
       +
       basic_zero: 0.0

     

       7
       7
       +
       small_positive: 0.5

     

       8
       8
       +
       small_negative: -0.5

     

       9
       9
       +
       

     

       10
       10
       +
       # Leading dot (no leading zero)

     

       11
       11
       +
       leading_dot: .5

     

       12
       12
       +
       leading_dot_negative: -.5

     

       13
       13
       +
       leading_dot_positive: +.5

     

       14
       14
       +
       leading_dot_long: .123456789

     

       15
       15
       +
       

     

       16
       16
       +
       # Trailing zeros

     

       17
       17
       +
       trailing_zero: 1.0

     

       18
       18
       +
       trailing_zeros: 1.00

     

       19
       19
       +
       many_trailing: 3.14000

     

       20
       20
       +
       

     

       21
       21
       +
       # Scientific notation - lowercase e

     

       22
       22
       +
       sci_positive: 1e10

     

       23
       23
       +
       sci_negative: 1e-10

     

       24
       24
       +
       sci_explicit_positive: 1e+10

     

       25
       25
       +
       sci_with_decimal: 1.5e10

     

       26
       26
       +
       sci_small: 6.022e23

     

       27
       27
       +
       sci_tiny: 1.6e-19

     

       28
       28
       +
       

     

       29
       29
       +
       # Scientific notation - uppercase E

     

       30
       30
       +
       sci_upper: 1E10

     

       31
       31
       +
       sci_upper_negative: 1E-10

     

       32
       32
       +
       sci_upper_explicit: 1E+10

     

       33
       33
       +
       sci_upper_decimal: 2.5E8

     

       34
       34
       +
       

     

       35
       35
       +
       # Negative numbers with scientific notation

     

       36
       36
       +
       neg_sci: -1e10

     

       37
       37
       +
       neg_sci_negative_exp: -1e-10

     

       38
       38
       +
       neg_sci_decimal: -3.14e5

     

       39
       39
       +
       

     

       40
       40
       +
       # Positive sign

     

       41
       41
       +
       positive_sign: +3.14

     

       42
       42
       +
       positive_sci: +1e10

     

       43
       43
       +
       positive_small: +0.001

     

       44
       44
       +
       

     

       45
       45
       +
       # Large and small values

     

       46
       46
       +
       very_large: 1e100

     

       47
       47
       +
       very_small: 1e-100

     

       48
       48
       +
       large_decimal: 999999999.999999

     

       49
       49
       +
       small_decimal: 0.000000001

     

       50
       50
       +
       

     

       51
       51
       +
       # Edge cases

     

       52
       52
       +
       negative_zero: -0.0

     

       53
       53
       +
       positive_zero: +0.0

     

       54
       54
       +
       one: 1.0

     

       55
       55
       +
       minus_one: -1.0

     

       56
       56
       +
       

     

       57
       57
       +
       # Real-world examples

     

       58
       58
       +
       pi: 3.14159265359

     

       59
       59
       +
       euler: 2.71828182845

     

       60
       60
       +
       golden_ratio: 1.61803398875

     

       61
       61
       +
       planck: 6.62607015e-34

     

       62
       62
       +
       avogadro: 6.02214076e23

     

       63
       63
       +
       speed_of_light: 299792458.0

     

       64
       64
       +
       gravitational_constant: 6.674e-11

     

       65
       65
       +
       

     

       66
       66
       +
       # Coordinates example

     

       67
       67
       +
       coordinates:

     

       68
       68
       +
         latitude: 37.7749

     

       69
       69
       +
         longitude: -122.4194

     

       70
       70
       +
         altitude: 16.0

     

       71
       71
       +
       

     

       72
       72
       +
       # Financial examples

     

       73
       73
       +
       prices:

     

       74
       74
       +
         item1: 19.99

     

       75
       75
       +
         item2: 0.99

     

       76
       76
       +
         discount: -5.00

     

       77
       77
       +
         tax_rate: 0.0825

     

       78
       78
       +
       

     

       79
       79
       +
       # Measurements

     

       80
       80
       +
       measurements:

     

       81
       81
       +
         temperature_c: 23.5

     

       82
       82
       +
         temperature_f: 74.3

     

       83
       83
       +
         humidity: 0.65

     

       84
       84
       +
         pressure_hpa: 1013.25

     

       85
       85
       +
       

     

       86
       86
       +
       # Mixed in sequences

     

       87
       87
       +
       float_sequence:

     

       88
       88
       +
         - 1.0

     

       89
       89
       +
         - -1.0

     

       90
       90
       +
         - 0.5

     

       91
       91
       +
         - -0.5

     

       92
       92
       +
         - 1e10

     

       93
       93
       +
         - 1e-10

     

       94
       94
       +
         - .5

     

       95
       95
       +
         - -.5

     

       96
       96
       +
       

     

       97
       97
       +
       # Integers that should stay as integers (for comparison)

     

       98
       98
       +
       integers:

     

       99
       99
       +
         simple: 42

     

       100
       100
       +
         negative: -17

     

       101
       101
       +
         zero: 0

     

       102
       102
       +
         hex: 0x1A

     

       103
       103
       +
         octal: 0o14

+286

tests/cram/values.t

···

       1
       1
       +
       Test YAML null values from values_null.yml

     

       2
       2
       +
       

     

       3
       3
       +
         $ yamlcat values_null.yml

     

       4
       4
       +
         explicit_null: null

     

       5
       5
       +
         tilde_null: null

     

       6
       6
       +
         empty_null: null

     

       7
       7
       +
         flow_null:

     

       8
       8
       +
           - null

     

       9
       9
       +
           - null

     

       10
       10
       +
         sequence_nulls:

     

       11
       11
       +
           - null

     

       12
       12
       +
           - null

     

       13
       13
       +
           - null

     

       14
       14
       +
           - explicit: null

     

       15
       15
       +
           - tilde: null

     

       16
       16
       +
           - empty: null

     

       17
       17
       +
         mapping_nulls:

     

       18
       18
       +
           key1: null

     

       19
       19
       +
           key2: null

     

       20
       20
       +
           key3: null

     

       21
       21
       +
         'null': null key with string value

     

       22
       22
       +
         '~': tilde key with string value

     

       23
       23
       +
         nested:

     

       24
       24
       +
           level1:

     

       25
       25
       +
             null_value: null

     

       26
       26
       +
             tilde_value: null

     

       27
       27
       +
             empty_value: null

     

       28
       28
       +
             list:

     

       29
       29
       +
               - null

     

       30
       30
       +
               - null

     

       31
       31
       +
               - null

     

       32
       32
       +
               - some_value

     

       33
       33
       +
             map:

     

       34
       34
       +
               a: null

     

       35
       35
       +
               b: null

     

       36
       36
       +
               c: null

     

       37
       37
       +
         string_nulls:

     

       38
       38
       +
           quoted_null: 'null'

     

       39
       39
       +
           quoted_tilde: '~'

     

       40
       40
       +
           null_in_string: this is null

     

       41
       41
       +
           word_null: 'null'

     

       42
       42
       +
       

     

       43
       43
       +
         $ yamlcat --json values_null.yml

     

       44
       44
       +
         {"explicit_null": null, "tilde_null": null, "empty_null": null, "flow_null": [null, null], "sequence_nulls": [null, null, null, {"explicit": null}, {"tilde": null}, {"empty": null}], "mapping_nulls": {"key1": null, "key2": null, "key3": null}, "null": "null key with string value", "~": "tilde key with string value", "nested": {"level1": {"null_value": null, "tilde_value": null, "empty_value": null, "list": [null, null, null, "some_value"], "map": {"a": null, "b": null, "c": null}}}, "string_nulls": {"quoted_null": "null", "quoted_tilde": "~", "null_in_string": "this is null", "word_null": "null"}}

     

       45
       45
       +
       

     

       46
       46
       +
       Test YAML boolean values from values_bool.yml

     

       47
       47
       +
       

     

       48
       48
       +
         $ yamlcat values_bool.yml

     

       49
       49
       +
         bool_true: true

     

       50
       50
       +
         bool_false: false

     

       51
       51
       +
         capitalized_true: true

     

       52
       52
       +
         capitalized_false: false

     

       53
       53
       +
         yes_value: true

     

       54
       54
       +
         no_value: false

     

       55
       55
       +
         Yes_value: true

     

       56
       56
       +
         No_value: false

     

       57
       57
       +
         YES_value: true

     

       58
       58
       +
         NO_value: false

     

       59
       59
       +
         on_value: true

     

       60
       60
       +
         off_value: false

     

       61
       61
       +
         On_value: true

     

       62
       62
       +
         Off_value: false

     

       63
       63
       +
         ON_value: true

     

       64
       64
       +
         OFF_value: false

     

       65
       65
       +
         bool_sequence:

     

       66
       66
       +
           - true

     

       67
       67
       +
           - false

     

       68
       68
       +
           - true

     

       69
       69
       +
           - false

     

       70
       70
       +
           - true

     

       71
       71
       +
           - false

     

       72
       72
       +
         flow_bools:

     

       73
       73
       +
           - true

     

       74
       74
       +
           - false

     

       75
       75
       +
           - true

     

       76
       76
       +
           - false

     

       77
       77
       +
         bool_mapping:

     

       78
       78
       +
           active: true

     

       79
       79
       +
           disabled: false

     

       80
       80
       +
           enabled: true

     

       81
       81
       +
           stopped: false

     

       82
       82
       +
         quoted_bools:

     

       83
       83
       +
           quoted_true: 'true'

     

       84
       84
       +
           quoted_false: 'false'

     

       85
       85
       +
           quoted_yes: 'yes'

     

       86
       86
       +
           quoted_no: 'no'

     

       87
       87
       +
           single_true: 'true'

     

       88
       88
       +
           single_false: 'false'

     

       89
       89
       +
         nested_bools:

     

       90
       90
       +
           settings:

     

       91
       91
       +
             debug: true

     

       92
       92
       +
             verbose: false

     

       93
       93
       +
             legacy_yes: true

     

       94
       94
       +
             legacy_no: false

     

       95
       95
       +
           flags:

     

       96
       96
       +
             - true

     

       97
       97
       +
             - false

     

       98
       98
       +
             - true

     

       99
       99
       +
             - false

     

       100
       100
       +
         mixed_case:

     

       101
       101
       +
           'TRUE': true

     

       102
       102
       +
           'FALSE': false

     

       103
       103
       +
           'TrUe': true

     

       104
       104
       +
           'FaLsE': false

     

       105
       105
       +
         bool_like_strings:

     

       106
       106
       +
           truthy: truely

     

       107
       107
       +
           falsy: falsetto

     

       108
       108
       +
           yes_sir: yessir

     

       109
       109
       +
           no_way: noway

     

       110
       110
       +
       

     

       111
       111
       +
         $ yamlcat --json values_bool.yml

     

       112
       112
       +
         {"bool_true": true, "bool_false": false, "capitalized_true": true, "capitalized_false": false, "yes_value": true, "no_value": false, "Yes_value": true, "No_value": false, "YES_value": true, "NO_value": false, "on_value": true, "off_value": false, "On_value": true, "Off_value": false, "ON_value": true, "OFF_value": false, "bool_sequence": [true, false, true, false, true, false], "flow_bools": [true, false, true, false], "bool_mapping": {"active": true, "disabled": false, "enabled": true, "stopped": false}, "quoted_bools": {"quoted_true": "true", "quoted_false": "false", "quoted_yes": "yes", "quoted_no": "no", "single_true": "true", "single_false": "false"}, "nested_bools": {"settings": {"debug": true, "verbose": false, "legacy_yes": true, "legacy_no": false}, "flags": [true, false, true, false]}, "mixed_case": {"TRUE": true, "FALSE": false, "TrUe": true, "FaLsE": false}, "bool_like_strings": {"truthy": "truely", "falsy": "falsetto", "yes_sir": "yessir", "no_way": "noway"}}

     

       113
       113
       +
       

     

       114
       114
       +
       Test YAML number values from values_numbers.yml

     

       115
       115
       +
       

     

       116
       116
       +
         $ yamlcat values_numbers.yml

     

       117
       117
       +
         int_zero: 0

     

       118
       118
       +
         int_positive: 42

     

       119
       119
       +
         int_negative: -17

     

       120
       120
       +
         int_large: 1000000

     

       121
       121
       +
         int_with_underscores: 1000000

     

       122
       122
       +
         octal_value: 12

     

       123
       123
       +
         octal_zero: 0

     

       124
       124
       +
         octal_large: 511

     

       125
       125
       +
         hex_lowercase: 26

     

       126
       126
       +
         hex_uppercase: 26

     

       127
       127
       +
         hex_mixed: 3735928559

     

       128
       128
       +
         hex_zero: 0

     

       129
       129
       +
         float_simple: 3.14

     

       130
       130
       +
         float_negative: -0.5

     

       131
       131
       +
         float_zero: 0

     

       132
       132
       +
         float_leading_dot: 0.5

     

       133
       133
       +
         float_trailing_zero: 1

     

       134
       134
       +
         scientific_positive: 10000000000

     

       135
       135
       +
         scientific_negative: 0.0015

     

       136
       136
       +
         scientific_uppercase: 250

     

       137
       137
       +
         scientific_no_sign: 300000

     

       138
       138
       +
         positive_infinity: .inf

     

       139
       139
       +
         negative_infinity: -.inf

     

       140
       140
       +
         not_a_number: .nan

     

       141
       141
       +
         infinity_upper: .inf

     

       142
       142
       +
         infinity_caps: .inf

     

       143
       143
       +
         nan_upper: .nan

     

       144
       144
       +
         nan_caps: .nan

     

       145
       145
       +
         number_sequence:

     

       146
       146
       +
           - 0

     

       147
       147
       +
           - 42

     

       148
       148
       +
           - -17

     

       149
       149
       +
           - 3.14

     

       150
       150
       +
           - 10000000000

     

       151
       151
       +
           - .inf

     

       152
       152
       +
           - .nan

     

       153
       153
       +
         flow_numbers:

     

       154
       154
       +
           - 0

     

       155
       155
       +
           - 42

     

       156
       156
       +
           - -17

     

       157
       157
       +
           - 3.14

     

       158
       158
       +
           - 26

     

       159
       159
       +
           - 12

     

       160
       160
       +
         number_mapping:

     

       161
       161
       +
           count: 100

     

       162
       162
       +
           price: 19.99

     

       163
       163
       +
           discount: -5

     

       164
       164
       +
           hex_color: 16734003

     

       165
       165
       +
           octal_perms: 493

     

       166
       166
       +
           scientific: 6.022e+23

     

       167
       167
       +
         quoted_numbers:

     

       168
       168
       +
           string_int: '42'

     

       169
       169
       +
           string_float: '3.14'

     

       170
       170
       +
           string_hex: '0x1A'

     

       171
       171
       +
           string_octal: 0o14

     

       172
       172
       +
           string_inf: '.inf'

     

       173
       173
       +
           string_nan: '.nan'

     

       174
       174
       +
         numeric_strings:

     

       175
       175
       +
           phone: 555-1234

     

       176
       176
       +
           version: 1.2.3

     

       177
       177
       +
           code: 123

     

       178
       178
       +
           leading_zero: 7

     

       179
       179
       +
           plus_sign: 123

     

       180
       180
       +
         edge_cases:

     

       181
       181
       +
           min_int: -9.22337e+18

     

       182
       182
       +
           max_int: 9.22337e+18

     

       183
       183
       +
           very_small: 1e-100

     

       184
       184
       +
           very_large: 1e+100

     

       185
       185
       +
           negative_zero: -0

     

       186
       186
       +
           positive_zero: 0

     

       187
       187
       +
         nested_numbers:

     

       188
       188
       +
           coordinates:

     

       189
       189
       +
             x: 10.5

     

       190
       190
       +
             y: -20.3

     

       191
       191
       +
             z: 0

     

       192
       192
       +
           measurements:

     

       193
       193
       +
             - 1.1

     

       194
       194
       +
             - 2.2

     

       195
       195
       +
             - 3.3

     

       196
       196
       +
           stats:

     

       197
       197
       +
             count: 1000

     

       198
       198
       +
             average: 45.67

     

       199
       199
       +
             max: .inf

     

       200
       200
       +
             min: -.inf

     

       201
       201
       +
         legacy_octal: 14

     

       202
       202
       +
         binary_like: 10

     

       203
       203
       +
         format_tests:

     

       204
       204
       +
           no_decimal: 42

     

       205
       205
       +
           with_decimal: 42

     

       206
       206
       +
           leading_zero_decimal: 0.42

     

       207
       207
       +
           no_leading_digit: 0.42

     

       208
       208
       +
           trailing_decimal: 42

     

       209
       209
       +
       

     

       210
       210
       +
         $ yamlcat --json values_numbers.yml

     

       211
       211
       +
         {"int_zero": 0, "int_positive": 42, "int_negative": -17, "int_large": 1000000, "int_with_underscores": 1000000, "octal_value": 12, "octal_zero": 0, "octal_large": 511, "hex_lowercase": 26, "hex_uppercase": 26, "hex_mixed": 3735928559, "hex_zero": 0, "float_simple": 3.14, "float_negative": -0.5, "float_zero": 0, "float_leading_dot": 0.5, "float_trailing_zero": 1, "scientific_positive": 10000000000, "scientific_negative": 0.0015, "scientific_uppercase": 250, "scientific_no_sign": 300000, "positive_infinity": inf, "negative_infinity": -inf, "not_a_number": nan, "infinity_upper": inf, "infinity_caps": inf, "nan_upper": nan, "nan_caps": nan, "number_sequence": [0, 42, -17, 3.14, 10000000000, inf, nan], "flow_numbers": [0, 42, -17, 3.14, 26, 12], "number_mapping": {"count": 100, "price": 19.99, "discount": -5, "hex_color": 16734003, "octal_perms": 493, "scientific": 6.022e+23}, "quoted_numbers": {"string_int": "42", "string_float": "3.14", "string_hex": "0x1A", "string_octal": "0o14", "string_inf": ".inf", "string_nan": ".nan"}, "numeric_strings": {"phone": "555-1234", "version": "1.2.3", "code": 123, "leading_zero": 7, "plus_sign": 123}, "edge_cases": {"min_int": -9.22337e+18, "max_int": 9.22337e+18, "very_small": 1e-100, "very_large": 1e+100, "negative_zero": -0, "positive_zero": 0}, "nested_numbers": {"coordinates": {"x": 10.5, "y": -20.3, "z": 0}, "measurements": [1.1, 2.2, 3.3], "stats": {"count": 1000, "average": 45.67, "max": inf, "min": -inf}}, "legacy_octal": 14, "binary_like": 10, "format_tests": {"no_decimal": 42, "with_decimal": 42, "leading_zero_decimal": 0.42, "no_leading_digit": 0.42, "trailing_decimal": 42}}

     

       212
       212
       +
       

     

       213
       213
       +
       Test YAML timestamp values from values_timestamps.yml

     

       214
       214
       +
       

     

       215
       215
       +
         $ yamlcat values_timestamps.yml

     

       216
       216
       +
         date_simple: 2001-12-15

     

       217
       217
       +
         date_earliest: 1970-01-01

     

       218
       218
       +
         date_leap_year: 2020-02-29

     

       219
       219
       +
         date_current: 2025-12-04

     

       220
       220
       +
         datetime_utc: '2001-12-15T02:59:43.1Z'

     

       221
       221
       +
         datetime_utc_full: '2001-12-15T02:59:43.123456Z'

     

       222
       222
       +
         datetime_utc_no_frac: '2001-12-15T02:59:43Z'

     

       223
       223
       +
         datetime_offset_pos: '2001-12-15T02:59:43.1+05:30'

     

       224
       224
       +
         datetime_offset_neg: '2001-12-15T02:59:43.1-05:00'

     

       225
       225
       +
         datetime_offset_hours: '2001-12-15T02:59:43+05'

     

       226
       226
       +
         datetime_spaced: '2001-12-14 21:59:43.10 -5'

     

       227
       227
       +
         datetime_spaced_utc: '2001-12-15 02:59:43.1 Z'

     

       228
       228
       +
         datetime_spaced_offset: '2001-12-14 21:59:43.10 -05:00'

     

       229
       229
       +
         datetime_no_frac: '2001-12-15T14:30:00Z'

     

       230
       230
       +
         date_only: 2001-12-15

     

       231
       231
       +
         timestamp_formats:

     

       232
       232
       +
           iso_date: 2001-12-15

     

       233
       233
       +
           iso_datetime_z: '2001-12-15T02:59:43Z'

     

       234
       234
       +
           iso_datetime_offset: '2001-12-15T02:59:43+00:00'

     

       235
       235
       +
           spaced_datetime: '2001-12-14 21:59:43.10 -5'

     

       236
       236
       +
           canonical: '2001-12-15T02:59:43.1Z'

     

       237
       237
       +
         timestamp_sequence:

     

       238
       238
       +
           - 2001-12-15

     

       239
       239
       +
           - '2001-12-15T02:59:43.1Z'

     

       240
       240
       +
           - '2001-12-14 21:59:43.10 -5'

     

       241
       241
       +
           - '2025-01-01T00:00:00Z'

     

       242
       242
       +
         events:

     

       243
       243
       +
           created: '2001-12-15T02:59:43.1Z'

     

       244
       244
       +
           modified: '2001-12-16T10:30:00Z'

     

       245
       245
       +
           published: '2001-12-14 21:59:43.10 -5'

     

       246
       246
       +
         quoted_timestamps:

     

       247
       247
       +
           string_date: 2001-12-15

     

       248
       248
       +
           string_datetime: '2001-12-15T02:59:43.1Z'

     

       249
       249
       +
           string_spaced: '2001-12-14 21:59:43.10 -5'

     

       250
       250
       +
         edge_cases:

     

       251
       251
       +
           midnight: '2001-12-15T00:00:00Z'

     

       252
       252
       +
           end_of_day: '2001-12-15T23:59:59Z'

     

       253
       253
       +
           microseconds: '2001-12-15T02:59:43.123456Z'

     

       254
       254
       +
           no_seconds: '2001-12-15T02:59Z'

     

       255
       255
       +
           hour_only: 2001-12-15T02Z

     

       256
       256
       +
         nested_timestamps:

     

       257
       257
       +
           project:

     

       258
       258
       +
             start_date: 2001-12-15

     

       259
       259
       +
             milestones:

     

       260
       260
       +
               - date: 2001-12-20

     

       261
       261
       +
                 time: '2001-12-20T14:00:00Z'

     

       262
       262
       +
               - date: 2002-01-15

     

       263
       263
       +
                 time: '2002-01-15T09:30:00-05:00'

     

       264
       264
       +
             metadata:

     

       265
       265
       +
               created: '2001-12-14 21:59:43.10 -5'

     

       266
       266
       +
               updated: '2001-12-15T02:59:43.1Z'

     

       267
       267
       +
         invalid_timestamps:

     

       268
       268
       +
           bad_date: 2001-13-45

     

       269
       269
       +
           bad_time: '2001-12-15T25:99:99Z'

     

       270
       270
       +
           incomplete: 2001-12

     

       271
       271
       +
           no_leading_zero: 2001-1-5

     

       272
       272
       +
         timezones:

     

       273
       273
       +
           utc_z: '2001-12-15T02:59:43Z'

     

       274
       274
       +
           utc_offset: '2001-12-15T02:59:43+00:00'

     

       275
       275
       +
           est: '2001-12-14T21:59:43-05:00'

     

       276
       276
       +
           ist: '2001-12-15T08:29:43+05:30'

     

       277
       277
       +
           jst: '2001-12-15T11:59:43+09:00'

     

       278
       278
       +
         date_range:

     

       279
       279
       +
           past: 1900-01-01

     

       280
       280
       +
           unix_epoch: '1970-01-01T00:00:00Z'

     

       281
       281
       +
           y2k: '2000-01-01T00:00:00Z'

     

       282
       282
       +
           present: 2025-12-04

     

       283
       283
       +
           future: '2099-12-31T23:59:59Z'

     

       284
       284
       +
       

     

       285
       285
       +
         $ yamlcat --json values_timestamps.yml

     

       286
       286
       +
         {"date_simple": "2001-12-15", "date_earliest": "1970-01-01", "date_leap_year": "2020-02-29", "date_current": "2025-12-04", "datetime_utc": "2001-12-15T02:59:43.1Z", "datetime_utc_full": "2001-12-15T02:59:43.123456Z", "datetime_utc_no_frac": "2001-12-15T02:59:43Z", "datetime_offset_pos": "2001-12-15T02:59:43.1+05:30", "datetime_offset_neg": "2001-12-15T02:59:43.1-05:00", "datetime_offset_hours": "2001-12-15T02:59:43+05", "datetime_spaced": "2001-12-14 21:59:43.10 -5", "datetime_spaced_utc": "2001-12-15 02:59:43.1 Z", "datetime_spaced_offset": "2001-12-14 21:59:43.10 -05:00", "datetime_no_frac": "2001-12-15T14:30:00Z", "date_only": "2001-12-15", "timestamp_formats": {"iso_date": "2001-12-15", "iso_datetime_z": "2001-12-15T02:59:43Z", "iso_datetime_offset": "2001-12-15T02:59:43+00:00", "spaced_datetime": "2001-12-14 21:59:43.10 -5", "canonical": "2001-12-15T02:59:43.1Z"}, "timestamp_sequence": ["2001-12-15", "2001-12-15T02:59:43.1Z", "2001-12-14 21:59:43.10 -5", "2025-01-01T00:00:00Z"], "events": {"created": "2001-12-15T02:59:43.1Z", "modified": "2001-12-16T10:30:00Z", "published": "2001-12-14 21:59:43.10 -5"}, "quoted_timestamps": {"string_date": "2001-12-15", "string_datetime": "2001-12-15T02:59:43.1Z", "string_spaced": "2001-12-14 21:59:43.10 -5"}, "edge_cases": {"midnight": "2001-12-15T00:00:00Z", "end_of_day": "2001-12-15T23:59:59Z", "microseconds": "2001-12-15T02:59:43.123456Z", "no_seconds": "2001-12-15T02:59Z", "hour_only": "2001-12-15T02Z"}, "nested_timestamps": {"project": {"start_date": "2001-12-15", "milestones": [{"date": "2001-12-20", "time": "2001-12-20T14:00:00Z"}, {"date": "2002-01-15", "time": "2002-01-15T09:30:00-05:00"}], "metadata": {"created": "2001-12-14 21:59:43.10 -5", "updated": "2001-12-15T02:59:43.1Z"}}}, "invalid_timestamps": {"bad_date": "2001-13-45", "bad_time": "2001-12-15T25:99:99Z", "incomplete": "2001-12", "no_leading_zero": "2001-1-5"}, "timezones": {"utc_z": "2001-12-15T02:59:43Z", "utc_offset": "2001-12-15T02:59:43+00:00", "est": "2001-12-14T21:59:43-05:00", "ist": "2001-12-15T08:29:43+05:30", "jst": "2001-12-15T11:59:43+09:00"}, "date_range": {"past": "1900-01-01", "unix_epoch": "1970-01-01T00:00:00Z", "y2k": "2000-01-01T00:00:00Z", "present": "2025-12-04", "future": "2099-12-31T23:59:59Z"}}

+82

tests/cram/values_bool.yml

···

       1
       1
       +
       # Boolean value test cases for YAML 1.2

     

       2
       2
       +
       # Note: YAML 1.2 only recognizes 'true' and 'false' as booleans

     

       3
       3
       +
       # Other values like yes/no, on/off are treated as strings in 1.2

     

       4
       4
       +
       

     

       5
       5
       +
       # Standard YAML 1.2 booleans (lowercase)

     

       6
       6
       +
       bool_true: true

     

       7
       7
       +
       bool_false: false

     

       8
       8
       +
       

     

       9
       9
       +
       # Capitalized forms (should be strings in YAML 1.2)

     

       10
       10
       +
       capitalized_true: True

     

       11
       11
       +
       capitalized_false: False

     

       12
       12
       +
       

     

       13
       13
       +
       # YAML 1.1 style booleans (should be strings in YAML 1.2)

     

       14
       14
       +
       yes_value: yes

     

       15
       15
       +
       no_value: no

     

       16
       16
       +
       Yes_value: Yes

     

       17
       17
       +
       No_value: No

     

       18
       18
       +
       YES_value: YES

     

       19
       19
       +
       NO_value: NO

     

       20
       20
       +
       

     

       21
       21
       +
       # On/Off style (should be strings in YAML 1.2)

     

       22
       22
       +
       on_value: on

     

       23
       23
       +
       off_value: off

     

       24
       24
       +
       On_value: On

     

       25
       25
       +
       Off_value: Off

     

       26
       26
       +
       ON_value: ON

     

       27
       27
       +
       OFF_value: OFF

     

       28
       28
       +
       

     

       29
       29
       +
       # Booleans in sequences

     

       30
       30
       +
       bool_sequence:

     

       31
       31
       +
         - true

     

       32
       32
       +
         - false

     

       33
       33
       +
         - yes

     

       34
       34
       +
         - no

     

       35
       35
       +
         - on

     

       36
       36
       +
         - off

     

       37
       37
       +
       

     

       38
       38
       +
       # Booleans in flow style

     

       39
       39
       +
       flow_bools: [true, false, yes, no]

     

       40
       40
       +
       

     

       41
       41
       +
       # Booleans in mappings

     

       42
       42
       +
       bool_mapping:

     

       43
       43
       +
         active: true

     

       44
       44
       +
         disabled: false

     

       45
       45
       +
         enabled: yes

     

       46
       46
       +
         stopped: no

     

       47
       47
       +
       

     

       48
       48
       +
       # String literals that should NOT be parsed as booleans

     

       49
       49
       +
       quoted_bools:

     

       50
       50
       +
         quoted_true: "true"

     

       51
       51
       +
         quoted_false: "false"

     

       52
       52
       +
         quoted_yes: "yes"

     

       53
       53
       +
         quoted_no: "no"

     

       54
       54
       +
         single_true: 'true'

     

       55
       55
       +
         single_false: 'false'

     

       56
       56
       +
       

     

       57
       57
       +
       # Nested boolean values

     

       58
       58
       +
       nested_bools:

     

       59
       59
       +
         settings:

     

       60
       60
       +
           debug: true

     

       61
       61
       +
           verbose: false

     

       62
       62
       +
           legacy_yes: yes

     

       63
       63
       +
           legacy_no: no

     

       64
       64
       +
         flags:

     

       65
       65
       +
           - true

     

       66
       66
       +
           - false

     

       67
       67
       +
           - on

     

       68
       68
       +
           - off

     

       69
       69
       +
       

     

       70
       70
       +
       # Mixed case variations

     

       71
       71
       +
       mixed_case:

     

       72
       72
       +
         TRUE: TRUE

     

       73
       73
       +
         FALSE: FALSE

     

       74
       74
       +
         TrUe: TrUe

     

       75
       75
       +
         FaLsE: FaLsE

     

       76
       76
       +
       

     

       77
       77
       +
       # Boolean-like strings that should remain strings

     

       78
       78
       +
       bool_like_strings:

     

       79
       79
       +
         truthy: truely

     

       80
       80
       +
         falsy: falsetto

     

       81
       81
       +
         yes_sir: yessir

     

       82
       82
       +
         no_way: noway

+55

tests/cram/values_null.yml

···

       1
       1
       +
       # Null value test cases for YAML 1.2

     

       2
       2
       +
       

     

       3
       3
       +
       # Explicit null keyword

     

       4
       4
       +
       explicit_null: null

     

       5
       5
       +
       

     

       6
       6
       +
       # Tilde shorthand for null

     

       7
       7
       +
       tilde_null: ~

     

       8
       8
       +
       

     

       9
       9
       +
       # Empty value (implicit null)

     

       10
       10
       +
       empty_null:

     

       11
       11
       +
       

     

       12
       12
       +
       # Null in flow style

     

       13
       13
       +
       flow_null: [null, ~, ]

     

       14
       14
       +
       

     

       15
       15
       +
       # Null in sequences

     

       16
       16
       +
       sequence_nulls:

     

       17
       17
       +
         - null

     

       18
       18
       +
         - ~

     

       19
       19
       +
         -

     

       20
       20
       +
         - explicit: null

     

       21
       21
       +
         - tilde: ~

     

       22
       22
       +
         - empty:

     

       23
       23
       +
       

     

       24
       24
       +
       # Null in mappings

     

       25
       25
       +
       mapping_nulls:

     

       26
       26
       +
         key1: null

     

       27
       27
       +
         key2: ~

     

       28
       28
       +
         key3:

     

       29
       29
       +
       

     

       30
       30
       +
       # Null as key

     

       31
       31
       +
       null: "null key with string value"

     

       32
       32
       +
       ~: "tilde key with string value"

     

       33
       33
       +
       

     

       34
       34
       +
       # Mixed null values in nested structures

     

       35
       35
       +
       nested:

     

       36
       36
       +
         level1:

     

       37
       37
       +
           null_value: null

     

       38
       38
       +
           tilde_value: ~

     

       39
       39
       +
           empty_value:

     

       40
       40
       +
           list:

     

       41
       41
       +
             - null

     

       42
       42
       +
             - ~

     

       43
       43
       +
             -

     

       44
       44
       +
             - some_value

     

       45
       45
       +
           map:

     

       46
       46
       +
             a: null

     

       47
       47
       +
             b: ~

     

       48
       48
       +
             c:

     

       49
       49
       +
       

     

       50
       50
       +
       # String literals that contain "null" (should NOT be parsed as null)

     

       51
       51
       +
       string_nulls:

     

       52
       52
       +
         quoted_null: "null"

     

       53
       53
       +
         quoted_tilde: "~"

     

       54
       54
       +
         null_in_string: "this is null"

     

       55
       55
       +
         word_null: 'null'

+120

tests/cram/values_numbers.yml

···

       1
       1
       +
       # Numeric value test cases for YAML 1.2

     

       2
       2
       +
       

     

       3
       3
       +
       # Integers

     

       4
       4
       +
       int_zero: 0

     

       5
       5
       +
       int_positive: 42

     

       6
       6
       +
       int_negative: -17

     

       7
       7
       +
       int_large: 1000000

     

       8
       8
       +
       int_with_underscores: 1_000_000

     

       9
       9
       +
       

     

       10
       10
       +
       # Octal notation (YAML 1.2 style with 0o prefix)

     

       11
       11
       +
       octal_value: 0o14

     

       12
       12
       +
       octal_zero: 0o0

     

       13
       13
       +
       octal_large: 0o777

     

       14
       14
       +
       

     

       15
       15
       +
       # Hexadecimal notation

     

       16
       16
       +
       hex_lowercase: 0x1a

     

       17
       17
       +
       hex_uppercase: 0x1A

     

       18
       18
       +
       hex_mixed: 0xDeadBeef

     

       19
       19
       +
       hex_zero: 0x0

     

       20
       20
       +
       

     

       21
       21
       +
       # Floating point numbers

     

       22
       22
       +
       float_simple: 3.14

     

       23
       23
       +
       float_negative: -0.5

     

       24
       24
       +
       float_zero: 0.0

     

       25
       25
       +
       float_leading_dot: .5

     

       26
       26
       +
       float_trailing_zero: 1.0

     

       27
       27
       +
       

     

       28
       28
       +
       # Scientific notation

     

       29
       29
       +
       scientific_positive: 1.0e10

     

       30
       30
       +
       scientific_negative: 1.5e-3

     

       31
       31
       +
       scientific_uppercase: 2.5E+2

     

       32
       32
       +
       scientific_no_sign: 3.0e5

     

       33
       33
       +
       

     

       34
       34
       +
       # Special floating point values

     

       35
       35
       +
       positive_infinity: .inf

     

       36
       36
       +
       negative_infinity: -.inf

     

       37
       37
       +
       not_a_number: .nan

     

       38
       38
       +
       infinity_upper: .Inf

     

       39
       39
       +
       infinity_caps: .INF

     

       40
       40
       +
       nan_upper: .NaN

     

       41
       41
       +
       nan_caps: .NAN

     

       42
       42
       +
       

     

       43
       43
       +
       # Numbers in sequences

     

       44
       44
       +
       number_sequence:

     

       45
       45
       +
         - 0

     

       46
       46
       +
         - 42

     

       47
       47
       +
         - -17

     

       48
       48
       +
         - 3.14

     

       49
       49
       +
         - 1.0e10

     

       50
       50
       +
         - .inf

     

       51
       51
       +
         - .nan

     

       52
       52
       +
       

     

       53
       53
       +
       # Numbers in flow style

     

       54
       54
       +
       flow_numbers: [0, 42, -17, 3.14, 0x1A, 0o14]

     

       55
       55
       +
       

     

       56
       56
       +
       # Numbers in mappings

     

       57
       57
       +
       number_mapping:

     

       58
       58
       +
         count: 100

     

       59
       59
       +
         price: 19.99

     

       60
       60
       +
         discount: -5.0

     

       61
       61
       +
         hex_color: 0xFF5733

     

       62
       62
       +
         octal_perms: 0o755

     

       63
       63
       +
         scientific: 6.022e23

     

       64
       64
       +
       

     

       65
       65
       +
       # String literals that look like numbers (quoted)

     

       66
       66
       +
       quoted_numbers:

     

       67
       67
       +
         string_int: "42"

     

       68
       68
       +
         string_float: "3.14"

     

       69
       69
       +
         string_hex: "0x1A"

     

       70
       70
       +
         string_octal: "0o14"

     

       71
       71
       +
         string_inf: ".inf"

     

       72
       72
       +
         string_nan: ".nan"

     

       73
       73
       +
       

     

       74
       74
       +
       # Numeric strings that should remain strings

     

       75
       75
       +
       numeric_strings:

     

       76
       76
       +
         phone: 555-1234

     

       77
       77
       +
         version: 1.2.3

     

       78
       78
       +
         code: 00123

     

       79
       79
       +
         leading_zero: 007

     

       80
       80
       +
         plus_sign: +123

     

       81
       81
       +
       

     

       82
       82
       +
       # Edge cases

     

       83
       83
       +
       edge_cases:

     

       84
       84
       +
         min_int: -9223372036854775808

     

       85
       85
       +
         max_int: 9223372036854775807

     

       86
       86
       +
         very_small: 1.0e-100

     

       87
       87
       +
         very_large: 1.0e100

     

       88
       88
       +
         negative_zero: -0.0

     

       89
       89
       +
         positive_zero: +0.0

     

       90
       90
       +
       

     

       91
       91
       +
       # Nested numeric values

     

       92
       92
       +
       nested_numbers:

     

       93
       93
       +
         coordinates:

     

       94
       94
       +
           x: 10.5

     

       95
       95
       +
           y: -20.3

     

       96
       96
       +
           z: 0.0

     

       97
       97
       +
         measurements:

     

       98
       98
       +
           - 1.1

     

       99
       99
       +
           - 2.2

     

       100
       100
       +
           - 3.3

     

       101
       101
       +
         stats:

     

       102
       102
       +
           count: 1000

     

       103
       103
       +
           average: 45.67

     

       104
       104
       +
           max: .inf

     

       105
       105
       +
           min: -.inf

     

       106
       106
       +
       

     

       107
       107
       +
       # YAML 1.1 style octals (no 0o prefix) - should be strings in YAML 1.2

     

       108
       108
       +
       legacy_octal: 014

     

       109
       109
       +
       

     

       110
       110
       +
       # Binary notation (not part of YAML 1.2 core, but sometimes supported)

     

       111
       111
       +
       # These should be treated as strings in strict YAML 1.2

     

       112
       112
       +
       binary_like: 0b1010

     

       113
       113
       +
       

     

       114
       114
       +
       # Numbers with various formats

     

       115
       115
       +
       format_tests:

     

       116
       116
       +
         no_decimal: 42

     

       117
       117
       +
         with_decimal: 42.0

     

       118
       118
       +
         leading_zero_decimal: 0.42

     

       119
       119
       +
         no_leading_digit: .42

     

       120
       120
       +
         trailing_decimal: 42.

+101

tests/cram/values_timestamps.yml

···

       1
       1
       +
       # Timestamp value test cases for YAML 1.1

     

       2
       2
       +
       # Note: YAML 1.2 does not have a timestamp type in the core schema

     

       3
       3
       +
       # These are recognized in YAML 1.1 and some extended schemas

     

       4
       4
       +
       

     

       5
       5
       +
       # ISO 8601 date format (YYYY-MM-DD)

     

       6
       6
       +
       date_simple: 2001-12-15

     

       7
       7
       +
       date_earliest: 1970-01-01

     

       8
       8
       +
       date_leap_year: 2020-02-29

     

       9
       9
       +
       date_current: 2025-12-04

     

       10
       10
       +
       

     

       11
       11
       +
       # ISO 8601 datetime with timezone (UTC)

     

       12
       12
       +
       datetime_utc: 2001-12-15T02:59:43.1Z

     

       13
       13
       +
       datetime_utc_full: 2001-12-15T02:59:43.123456Z

     

       14
       14
       +
       datetime_utc_no_frac: 2001-12-15T02:59:43Z

     

       15
       15
       +
       

     

       16
       16
       +
       # ISO 8601 datetime with timezone offset

     

       17
       17
       +
       datetime_offset_pos: 2001-12-15T02:59:43.1+05:30

     

       18
       18
       +
       datetime_offset_neg: 2001-12-15T02:59:43.1-05:00

     

       19
       19
       +
       datetime_offset_hours: 2001-12-15T02:59:43+05

     

       20
       20
       +
       

     

       21
       21
       +
       # Spaced datetime format (YAML 1.1 style)

     

       22
       22
       +
       datetime_spaced: 2001-12-14 21:59:43.10 -5

     

       23
       23
       +
       datetime_spaced_utc: 2001-12-15 02:59:43.1 Z

     

       24
       24
       +
       datetime_spaced_offset: 2001-12-14 21:59:43.10 -05:00

     

       25
       25
       +
       

     

       26
       26
       +
       # Datetime without fractional seconds

     

       27
       27
       +
       datetime_no_frac: 2001-12-15T14:30:00Z

     

       28
       28
       +
       

     

       29
       29
       +
       # Date only (no time component)

     

       30
       30
       +
       date_only: 2001-12-15

     

       31
       31
       +
       

     

       32
       32
       +
       # Various formats

     

       33
       33
       +
       timestamp_formats:

     

       34
       34
       +
         iso_date: 2001-12-15

     

       35
       35
       +
         iso_datetime_z: 2001-12-15T02:59:43Z

     

       36
       36
       +
         iso_datetime_offset: 2001-12-15T02:59:43+00:00

     

       37
       37
       +
         spaced_datetime: 2001-12-14 21:59:43.10 -5

     

       38
       38
       +
         canonical: 2001-12-15T02:59:43.1Z

     

       39
       39
       +
       

     

       40
       40
       +
       # Timestamps in sequences

     

       41
       41
       +
       timestamp_sequence:

     

       42
       42
       +
         - 2001-12-15

     

       43
       43
       +
         - 2001-12-15T02:59:43.1Z

     

       44
       44
       +
         - 2001-12-14 21:59:43.10 -5

     

       45
       45
       +
         - 2025-01-01T00:00:00Z

     

       46
       46
       +
       

     

       47
       47
       +
       # Timestamps in mappings

     

       48
       48
       +
       events:

     

       49
       49
       +
         created: 2001-12-15T02:59:43.1Z

     

       50
       50
       +
         modified: 2001-12-16T10:30:00Z

     

       51
       51
       +
         published: 2001-12-14 21:59:43.10 -5

     

       52
       52
       +
       

     

       53
       53
       +
       # String literals that look like timestamps (quoted)

     

       54
       54
       +
       quoted_timestamps:

     

       55
       55
       +
         string_date: "2001-12-15"

     

       56
       56
       +
         string_datetime: "2001-12-15T02:59:43.1Z"

     

       57
       57
       +
         string_spaced: "2001-12-14 21:59:43.10 -5"

     

       58
       58
       +
       

     

       59
       59
       +
       # Edge cases and variations

     

       60
       60
       +
       edge_cases:

     

       61
       61
       +
         midnight: 2001-12-15T00:00:00Z

     

       62
       62
       +
         end_of_day: 2001-12-15T23:59:59Z

     

       63
       63
       +
         microseconds: 2001-12-15T02:59:43.123456Z

     

       64
       64
       +
         no_seconds: 2001-12-15T02:59Z

     

       65
       65
       +
         hour_only: 2001-12-15T02Z

     

       66
       66
       +
       

     

       67
       67
       +
       # Nested timestamp values

     

       68
       68
       +
       nested_timestamps:

     

       69
       69
       +
         project:

     

       70
       70
       +
           start_date: 2001-12-15

     

       71
       71
       +
           milestones:

     

       72
       72
       +
             - date: 2001-12-20

     

       73
       73
       +
               time: 2001-12-20T14:00:00Z

     

       74
       74
       +
             - date: 2002-01-15

     

       75
       75
       +
               time: 2002-01-15T09:30:00-05:00

     

       76
       76
       +
           metadata:

     

       77
       77
       +
             created: 2001-12-14 21:59:43.10 -5

     

       78
       78
       +
             updated: 2001-12-15T02:59:43.1Z

     

       79
       79
       +
       

     

       80
       80
       +
       # Invalid timestamp formats (should be treated as strings)

     

       81
       81
       +
       invalid_timestamps:

     

       82
       82
       +
         bad_date: 2001-13-45

     

       83
       83
       +
         bad_time: 2001-12-15T25:99:99Z

     

       84
       84
       +
         incomplete: 2001-12

     

       85
       85
       +
         no_leading_zero: 2001-1-5

     

       86
       86
       +
       

     

       87
       87
       +
       # Different timezone representations

     

       88
       88
       +
       timezones:

     

       89
       89
       +
         utc_z: 2001-12-15T02:59:43Z

     

       90
       90
       +
         utc_offset: 2001-12-15T02:59:43+00:00

     

       91
       91
       +
         est: 2001-12-14T21:59:43-05:00

     

       92
       92
       +
         ist: 2001-12-15T08:29:43+05:30

     

       93
       93
       +
         jst: 2001-12-15T11:59:43+09:00

     

       94
       94
       +
       

     

       95
       95
       +
       # Historical and future dates

     

       96
       96
       +
       date_range:

     

       97
       97
       +
         past: 1900-01-01

     

       98
       98
       +
         unix_epoch: 1970-01-01T00:00:00Z

     

       99
       99
       +
         y2k: 2000-01-01T00:00:00Z

     

       100
       100
       +
         present: 2025-12-04

     

       101
       101
       +
         future: 2099-12-31T23:59:59Z

+105

tests/cram/whitespace.yml

···

       1
       1
       +
       # Whitespace handling test file

     

       2
       2
       +
       

     

       3
       3
       +
       # Section 1: Different indentation levels (2 spaces)

     

       4
       4
       +
       two_space_indent:

     

       5
       5
       +
         level1:

     

       6
       6
       +
           level2:

     

       7
       7
       +
             level3: value

     

       8
       8
       +
       

     

       9
       9
       +
       # Section 2: Four space indentation

     

       10
       10
       +
       four_space_indent:

     

       11
       11
       +
           level1:

     

       12
       12
       +
               level2:

     

       13
       13
       +
                   level3: value

     

       14
       14
       +
       

     

       15
       15
       +
       # Section 3: Mixed content with blank lines

     

       16
       16
       +
       

     

       17
       17
       +
       first_key: first_value

     

       18
       18
       +
       

     

       19
       19
       +
       

     

       20
       20
       +
       second_key: second_value

     

       21
       21
       +
       

     

       22
       22
       +
       

     

       23
       23
       +
       

     

       24
       24
       +
       third_key: third_value

     

       25
       25
       +
       

     

       26
       26
       +
       # Section 4: Sequences with varying indentation

     

       27
       27
       +
       sequence_2space:

     

       28
       28
       +
         - item1

     

       29
       29
       +
         - item2

     

       30
       30
       +
         - nested:

     

       31
       31
       +
             - nested_item1

     

       32
       32
       +
             - nested_item2

     

       33
       33
       +
       

     

       34
       34
       +
       sequence_4space:

     

       35
       35
       +
           - item1

     

       36
       36
       +
           - item2

     

       37
       37
       +
           - nested:

     

       38
       38
       +
               - nested_item1

     

       39
       39
       +
               - nested_item2

     

       40
       40
       +
       

     

       41
       41
       +
       # Section 5: Trailing whitespace (spaces after values - invisible but present)

     

       42
       42
       +
       trailing_spaces: value

     

       43
       43
       +
       another_key: another_value

     

       44
       44
       +
       

     

       45
       45
       +
       # Section 6: Leading whitespace preservation in literals

     

       46
       46
       +
       literal_block: |

     

       47
       47
       +
         This is a literal block

     

       48
       48
       +
           with preserved indentation

     

       49
       49
       +
             including extra spaces

     

       50
       50
       +
         and blank lines

     

       51
       51
       +
       

     

       52
       52
       +
         like this one above

     

       53
       53
       +
       

     

       54
       54
       +
       folded_block: >

     

       55
       55
       +
         This is a folded block

     

       56
       56
       +
         that will be folded into

     

       57
       57
       +
         a single line but preserves

     

       58
       58
       +
       

     

       59
       59
       +
         paragraph breaks like above

     

       60
       60
       +
       

     

       61
       61
       +
       # Section 7: Whitespace in flow collections

     

       62
       62
       +
       flow_with_spaces: [ item1 , item2 , item3 ]

     

       63
       63
       +
       flow_tight: [item1,item2,item3]

     

       64
       64
       +
       flow_map_spaces: { key1: value1 , key2: value2 }

     

       65
       65
       +
       flow_map_tight: {key1:value1,key2:value2}

     

       66
       66
       +
       

     

       67
       67
       +
       # Section 8: Multiple consecutive blank lines between top-level keys

     

       68
       68
       +
       key_before_blanks: value1

     

       69
       69
       +
       

     

       70
       70
       +
       

     

       71
       71
       +
       

     

       72
       72
       +
       

     

       73
       73
       +
       key_after_blanks: value2

     

       74
       74
       +
       

     

       75
       75
       +
       # Section 9: Indentation in mappings

     

       76
       76
       +
       mapping_indent:

     

       77
       77
       +
         key1: value1

     

       78
       78
       +
         key2: value2

     

       79
       79
       +
         nested:

     

       80
       80
       +
           nested_key1: nested_value1

     

       81
       81
       +
           nested_key2: nested_value2

     

       82
       82
       +
           deep_nested:

     

       83
       83
       +
             deep_key: deep_value

     

       84
       84
       +
       

     

       85
       85
       +
       # Section 10: Whitespace around colons and hyphens

     

       86
       86
       +
       no_space_colon:value

     

       87
       87
       +
       space_after_colon: value

     

       88
       88
       +
       spaces_around: value

     

       89
       89
       +
       - sequence_item_no_space

     

       90
       90
       +
         - nested_sequence

     

       91
       91
       +
       

     

       92
       92
       +
       # Section 11: Empty lines in sequences

     

       93
       93
       +
       sequence_with_blanks:

     

       94
       94
       +
         - item1

     

       95
       95
       +
       

     

       96
       96
       +
         - item2

     

       97
       97
       +
       

     

       98
       98
       +
         - item3

     

       99
       99
       +
       

     

       100
       100
       +
       # Section 12: Whitespace-only mapping values (implicit null)

     

       101
       101
       +
       explicit_null: null

     

       102
       102
       +
       implicit_null:

     

       103
       103
       +
       space_only:

     

       104
       104
       +
       

     

       105
       105
       +
       # End of whitespace test file

tests/cram/yaml-1.2.yml

···

       1
       1
       +
       - {"when the key is quoted":"space after colon can be omitted."}

     

       2
       2
       +
       - "quoted slashes \/ are allowed."

     

       3
       3
       +
       - {?"a key can be looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooger": "than 1024 when parsing is unambiguous before seeing the colon."}

+161

tests/cram/yamlcat.t

···

       1
       1
       +
       Test yamlcat with simple YAML

     

       2
       2
       +
       

     

       3
       3
       +
         $ echo 'hello: world' | yamlcat

     

       4
       4
       +
         hello: world

     

       5
       5
       +
       

     

       6
       6
       +
         $ echo 'name: Alice

     

       7
       7
       +
         > age: 30' | yamlcat

     

       8
       8
       +
         name: Alice

     

       9
       9
       +
         age: 30

     

       10
       10
       +
       

     

       11
       11
       +
       Test nested mappings

     

       12
       12
       +
       

     

       13
       13
       +
         $ echo 'server:

     

       14
       14
       +
         >   host: localhost

     

       15
       15
       +
         >   port: 8080

     

       16
       16
       +
         > database:

     

       17
       17
       +
         >   name: mydb' | yamlcat

     

       18
       18
       +
         server:

     

       19
       19
       +
           host: localhost

     

       20
       20
       +
           port: 8080

     

       21
       21
       +
         database:

     

       22
       22
       +
           name: mydb

     

       23
       23
       +
       

     

       24
       24
       +
       Test sequences

     

       25
       25
       +
       

     

       26
       26
       +
         $ echo '- apple

     

       27
       27
       +
         > - banana

     

       28
       28
       +
         > - cherry' | yamlcat

     

       29
       29
       +
         - apple

     

       30
       30
       +
         - banana

     

       31
       31
       +
         - cherry

     

       32
       32
       +
       

     

       33
       33
       +
       Test mapping with sequence value

     

       34
       34
       +
       

     

       35
       35
       +
         $ echo 'fruits:

     

       36
       36
       +
         >   - apple

     

       37
       37
       +
         >   - banana' | yamlcat

     

       38
       38
       +
         fruits:

     

       39
       39
       +
           - apple

     

       40
       40
       +
           - banana

     

       41
       41
       +
       

     

       42
       42
       +
       Test flow style output

     

       43
       43
       +
       

     

       44
       44
       +
         $ echo 'name: Alice

     

       45
       45
       +
         > hobbies:

     

       46
       46
       +
         >   - reading

     

       47
       47
       +
         >   - coding' | yamlcat --flow

     

       48
       48
       +
         {name: Alice, hobbies: [reading, coding]}

     

       49
       49
       +
       

     

       50
       50
       +
       Test JSON output

     

       51
       51
       +
       

     

       52
       52
       +
         $ echo 'name: Alice

     

       53
       53
       +
         > age: 30' | yamlcat --json

     

       54
       54
       +
         {"name": "Alice", "age": 30}

     

       55
       55
       +
       

     

       56
       56
       +
       Test seq.yml file (multiline plain scalar)

     

       57
       57
       +
       

     

       58
       58
       +
         $ yamlcat seq.yml

     

       59
       59
       +
         - hello - whats - up

     

       60
       60
       +
         - foo

     

       61
       61
       +
         - bar

     

       62
       62
       +
       

     

       63
       63
       +
       Test seq.yml roundtrip preserves data

     

       64
       64
       +
       

     

       65
       65
       +
         $ yamlcat --json seq.yml

     

       66
       66
       +
         ["hello - whats - up", "foo", "bar"]

     

       67
       67
       +
       

     

       68
       68
       +
       Test cohttp.yml

     

       69
       69
       +
       

     

       70
       70
       +
         $ yamlcat cohttp.yml

     

       71
       71
       +
         language: c

     

       72
       72
       +
         sudo: false

     

       73
       73
       +
         services:

     

       74
       74
       +
           - docker

     

       75
       75
       +
         install: 'wget https://raw.githubusercontent.com/ocaml/ocaml-travisci-skeleton/master/.travis-docker.sh'

     

       76
       76
       +
         script: bash -ex ./.travis-docker.sh

     

       77
       77
       +
         env:

     

       78
       78
       +
           global:

     

       79
       79
       +
             - "EXTRA_REMOTES=\"https://github.com/mirage/mirage-dev.git\""

     

       80
       80
       +
             - "PINS=\"cohttp-top:. cohttp-async:. cohttp-lwt-unix:. cohttp-lwt-jsoo:. cohttp-lwt:. cohttp-mirage:. cohttp:.\""

     

       81
       81
       +
           matrix:

     

       82
       82
       +
             - "PACKAGE=\"cohttp\" DISTRO=\"alpine-3.5\" OCAML_VERSION=\"4.06.0\""

     

       83
       83
       +
             - "PACKAGE=\"cohttp-async\" DISTRO=\"alpine\" OCAML_VERSION=\"4.06.0\""

     

       84
       84
       +
             - "PACKAGE=\"cohttp-lwt\" DISTRO=\"debian-unstable\" OCAML_VERSION=\"4.03.0\""

     

       85
       85
       +
             - "PACKAGE=\"cohttp-mirage\" DISTRO=\"debian-unstable\" OCAML_VERSION=\"4.03.0\""

     

       86
       86
       +
         notifications:

     

       87
       87
       +
           webhooks:

     

       88
       88
       +
             urls:

     

       89
       89
       +
               - 'https://webhooks.gitter.im/e/6ee5059c7420709f4ad1'

     

       90
       90
       +
             on_success: change

     

       91
       91
       +
             on_failure: always

     

       92
       92
       +
             on_start: false

     

       93
       93
       +
       

     

       94
       94
       +
       Test cohttp.yml roundtrip with JSON

     

       95
       95
       +
       

     

       96
       96
       +
         $ yamlcat --json cohttp.yml

     

       97
       97
       +
         {"language": "c", "sudo": false, "services": ["docker"], "install": "wget https://raw.githubusercontent.com/ocaml/ocaml-travisci-skeleton/master/.travis-docker.sh", "script": "bash -ex ./.travis-docker.sh", "env": {"global": ["EXTRA_REMOTES=\"https://github.com/mirage/mirage-dev.git\"", "PINS=\"cohttp-top:. cohttp-async:. cohttp-lwt-unix:. cohttp-lwt-jsoo:. cohttp-lwt:. cohttp-mirage:. cohttp:.\""], "matrix": ["PACKAGE=\"cohttp\" DISTRO=\"alpine-3.5\" OCAML_VERSION=\"4.06.0\"", "PACKAGE=\"cohttp-async\" DISTRO=\"alpine\" OCAML_VERSION=\"4.06.0\"", "PACKAGE=\"cohttp-lwt\" DISTRO=\"debian-unstable\" OCAML_VERSION=\"4.03.0\"", "PACKAGE=\"cohttp-mirage\" DISTRO=\"debian-unstable\" OCAML_VERSION=\"4.03.0\""]}, "notifications": {"webhooks": {"urls": ["https://webhooks.gitter.im/e/6ee5059c7420709f4ad1"], "on_success": "change", "on_failure": "always", "on_start": false}}}

     

       98
       98
       +
       

     

       99
       99
       +
       Test special values

     

       100
       100
       +
       

     

       101
       101
       +
         $ echo 'null_val: null

     

       102
       102
       +
         > bool_true: true

     

       103
       103
       +
         > bool_false: false

     

       104
       104
       +
         > number: 42

     

       105
       105
       +
         > float: 3.14' | yamlcat --json

     

       106
       106
       +
         {"null_val": null, "bool_true": true, "bool_false": false, "number": 42, "float": 3.14}

     

       107
       107
       +
       

     

       108
       108
       +
       Test quoted strings

     

       109
       109
       +
       

     

       110
       110
       +
         $ echo 'single: '"'"'hello world'"'"'

     

       111
       111
       +
         > double: "hello world"' | yamlcat

     

       112
       112
       +
         single: hello world

     

       113
       113
       +
         double: hello world

     

       114
       114
       +
       

     

       115
       115
       +
       Test literal block scalar

     

       116
       116
       +
       

     

       117
       117
       +
         $ echo 'text: |

     

       118
       118
       +
         >   line one

     

       119
       119
       +
         >   line two' | yamlcat --json

     

       120
       120
       +
         {"text": "line one\nline two\n"}

     

       121
       121
       +
       

     

       122
       122
       +
       Test folded block scalar

     

       123
       123
       +
       

     

       124
       124
       +
         $ echo 'text: >

     

       125
       125
       +
         >   line one

     

       126
       126
       +
         >   line two' | yamlcat --json

     

       127
       127
       +
         {"text": "line one line two\n"}

     

       128
       128
       +
       

     

       129
       129
       +
       Test linuxkit.yml (sequences of mappings)

     

       130
       130
       +
       

     

       131
       131
       +
         $ yamlcat linuxkit.yml | head -30

     

       132
       132
       +
         kernel:

     

       133
       133
       +
           image: 'linuxkit/kernel:4.9.40'

     

       134
       134
       +
           cmdline: console=tty0 console=ttyS0

     

       135
       135
       +
         init:

     

       136
       136
       +
           - 'linuxkit/init:906e174b3f2e07f97d6fd693a2e8518e98dafa58'

     

       137
       137
       +
           - 'linuxkit/runc:90e45f13e1d0a0983f36ef854621e3eac91cf541'

     

       138
       138
       +
           - 'linuxkit/containerd:7c986fb7df33bea73b5c8097b46989e46f49d875'

     

       139
       139
       +
           - 'linuxkit/ca-certificates:e44b0a66df5a102c0e220f0066b0d904710dcb10'

     

       140
       140
       +
         onboot:

     

       141
       141
       +
           - name: sysctl

     

       142
       142
       +
             image: 'linuxkit/sysctl:184c914d23a017062d7b53d7fc1dfaf47764bef6'

     

       143
       143
       +
           - name: dhcpcd

     

       144
       144
       +
             image: 'linuxkit/dhcpcd:f3f5413abb78fae9020e35bd4788fa93df4530b7'

     

       145
       145
       +
             command:

     

       146
       146
       +
               - /sbin/dhcpcd

     

       147
       147
       +
               - '--nobackground'

     

       148
       148
       +
               - '-f'

     

       149
       149
       +
               - /dhcpcd.conf

     

       150
       150
       +
               - '-1'

     

       151
       151
       +
         onshutdown:

     

       152
       152
       +
           - name: shutdown

     

       153
       153
       +
             image: 'busybox:latest'

     

       154
       154
       +
             command:

     

       155
       155
       +
               - /bin/echo

     

       156
       156
       +
               - so long and thanks for all the fish

     

       157
       157
       +
         services:

     

       158
       158
       +
           - name: getty

     

       159
       159
       +
             image: 'linuxkit/getty:2c841cdc34396e3fa8f25b62d112808f63f16df6'

     

       160
       160
       +
             env:

     

       161
       161
       +
               - INSECURE=true

+488

tests/run_all_tests.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
       +
       open Yamlrw

     

       7
       7
       +
       module TL = Test_suite_lib.Test_suite_loader

     

       8
       8
       +
       module TF = Test_suite_lib.Tree_format

     

       9
       9
       +
       module JF = Test_suite_lib.Json_format

     

       10
       10
       +
       module JC = Test_suite_lib.Json_compare

     

       11
       11
       +
       

     

       12
       12
       +
       let test_suite_path = "../yaml-test-suite"

     

       13
       13
       +
       

     

       14
       14
       +
       (* HTML escape function *)

     

       15
       15
       +
       let html_escape s =

     

       16
       16
       +
         let buf = Buffer.create (String.length s) in

     

       17
       17
       +
         String.iter (function

     

       18
       18
       +
           | '<' -> Buffer.add_string buf "&lt;"

     

       19
       19
       +
           | '>' -> Buffer.add_string buf "&gt;"

     

       20
       20
       +
           | '&' -> Buffer.add_string buf "&amp;"

     

       21
       21
       +
           | '"' -> Buffer.add_string buf "&quot;"

     

       22
       22
       +
           | c -> Buffer.add_char buf c

     

       23
       23
       +
         ) s;

     

       24
       24
       +
         Buffer.contents buf

     

       25
       25
       +
       

     

       26
       26
       +
       let normalize_tree s =

     

       27
       27
       +
         let lines = String.split_on_char '\n' s in

     

       28
       28
       +
         let lines = List.filter (fun l -> String.trim l <> "") lines in

     

       29
       29
       +
         String.concat "\n" lines

     

       30
       30
       +
       

     

       31
       31
       +
       type test_result = {

     

       32
       32
       +
         id : string;

     

       33
       33
       +
         name : string;

     

       34
       34
       +
         yaml : string;

     

       35
       35
       +
         is_error_test : bool;

     

       36
       36
       +
         status : [`Pass | `Fail of string | `Skip];

     

       37
       37
       +
         output : string;

     

       38
       38
       +
         json_status : [`Pass | `Fail of string | `Skip];

     

       39
       39
       +
         json_expected : string;

     

       40
       40
       +
         json_actual : string;

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       let compare_json expected actual =

     

       44
       44
       +
         (* Parse both JSON strings and compare the resulting structures.

     

       45
       45
       +
            This handles formatting differences and object key ordering. *)

     

       46
       46
       +
         JC.compare_json_strings expected actual

     

       47
       47
       +
       

     

       48
       48
       +
       let run_json_test (test : TL.test_case) : [`Pass | `Fail of string | `Skip] * string =

     

       49
       49
       +
         match test.json with

     

       50
       50
       +
         | None -> (`Skip, "")

     

       51
       51
       +
         | Some expected_json ->

     

       52
       52
       +
             if test.fail then

     

       53
       53
       +
               (* Error tests shouldn't have JSON comparison *)

     

       54
       54
       +
               (`Skip, "")

     

       55
       55
       +
             else

     

       56
       56
       +
               try

     

       57
       57
       +
                 (* Handle multi-document YAML by using documents_of_string *)

     

       58
       58
       +
                 let docs = Loader.documents_of_string test.yaml in

     

       59
       59
       +
                 let values = List.filter_map (fun doc ->

     

       60
       60
       +
                   match Document.root doc with

     

       61
       61
       +
                   | None -> None

     

       62
       62
       +
                   | Some yaml -> Some (Yaml.to_value ~resolve_aliases_first:true yaml)

     

       63
       63
       +
                 ) docs in

     

       64
       64
       +
                 let actual_json = match values with

     

       65
       65
       +
                   | [] -> ""  (* Empty document produces empty JSON *)

     

       66
       66
       +
                   | [v] -> JF.to_json v

     

       67
       67
       +
                   | vs -> JF.documents_to_json vs

     

       68
       68
       +
                 in

     

       69
       69
       +
                 if compare_json expected_json actual_json then

     

       70
       70
       +
                   (`Pass, actual_json)

     

       71
       71
       +
                 else

     

       72
       72
       +
                   (`Fail "JSON mismatch", actual_json)

     

       73
       73
       +
               with

     

       74
       74
       +
               | Yamlrw_error e ->

     

       75
       75
       +
                   (`Fail (Format.asprintf "Parse error: %a" Error.pp e), "")

     

       76
       76
       +
               | exn ->

     

       77
       77
       +
                   (`Fail (Printf.sprintf "Exception: %s" (Printexc.to_string exn)), "")

     

       78
       78
       +
       

     

       79
       79
       +
       let run_test (test : TL.test_case) : test_result =

     

       80
       80
       +
         let json_status, json_actual = run_json_test test in

     

       81
       81
       +
         let base = {

     

       82
       82
       +
           id = test.id;

     

       83
       83
       +
           name = test.name;

     

       84
       84
       +
           yaml = test.yaml;

     

       85
       85
       +
           is_error_test = test.fail;

     

       86
       86
       +
           status = `Skip;

     

       87
       87
       +
           output = "";

     

       88
       88
       +
           json_status;

     

       89
       89
       +
           json_expected = Option.value ~default:"" test.json;

     

       90
       90
       +
           json_actual;

     

       91
       91
       +
         } in

     

       92
       92
       +
         if test.fail then begin

     

       93
       93
       +
           try

     

       94
       94
       +
             let parser = Parser.of_string test.yaml in

     

       95
       95
       +
             let events = Parser.to_list parser in

     

       96
       96
       +
             let tree = TF.of_spanned_events events in

     

       97
       97
       +
             { base with

     

       98
       98
       +
               status = `Fail "Expected parsing to fail";

     

       99
       99
       +
               output = tree;

     

       100
       100
       +
             }

     

       101
       101
       +
           with

     

       102
       102
       +
           | Yamlrw_error e ->

     

       103
       103
       +
               { base with

     

       104
       104
       +
                 status = `Pass;

     

       105
       105
       +
                 output = Format.asprintf "%a" Error.pp e;

     

       106
       106
       +
               }

     

       107
       107
       +
           | exn ->

     

       108
       108
       +
               { base with

     

       109
       109
       +
                 status = `Pass;

     

       110
       110
       +
                 output = Printexc.to_string exn;

     

       111
       111
       +
               }

     

       112
       112
       +
         end

     

       113
       113
       +
         else begin

     

       114
       114
       +
           match test.tree with

     

       115
       115
       +
           | None ->

     

       116
       116
       +
               (* No expected tree - check if json indicates expected success *)

     

       117
       117
       +
               (match test.json with

     

       118
       118
       +
                | Some _ ->

     

       119
       119
       +
                    (* Has json output, so should parse successfully *)

     

       120
       120
       +
                    (try

     

       121
       121
       +
                      let parser = Parser.of_string test.yaml in

     

       122
       122
       +
                      let events = Parser.to_list parser in

     

       123
       123
       +
                      let tree = TF.of_spanned_events events in

     

       124
       124
       +
                      { base with status = `Pass; output = tree }

     

       125
       125
       +
                    with exn ->

     

       126
       126
       +
                      { base with

     

       127
       127
       +
                        status = `Fail (Printf.sprintf "Should parse but got: %s" (Printexc.to_string exn));

     

       128
       128
       +
                        output = Printexc.to_string exn;

     

       129
       129
       +
                      })

     

       130
       130
       +
                | None ->

     

       131
       131
       +
                    (* No tree, no json, no fail - ambiguous edge case, skip *)

     

       132
       132
       +
                    { base with status = `Skip; output = "(no expected tree or json)" })

     

       133
       133
       +
           | Some expected ->

     

       134
       134
       +
               try

     

       135
       135
       +
                 let parser = Parser.of_string test.yaml in

     

       136
       136
       +
                 let events = Parser.to_list parser in

     

       137
       137
       +
                 let actual = TF.of_spanned_events events in

     

       138
       138
       +
                 let expected_norm = normalize_tree expected in

     

       139
       139
       +
                 let actual_norm = normalize_tree actual in

     

       140
       140
       +
                 if expected_norm = actual_norm then

     

       141
       141
       +
                   { base with status = `Pass; output = actual }

     

       142
       142
       +
                 else

     

       143
       143
       +
                   { base with

     

       144
       144
       +
                     status = `Fail (Printf.sprintf "Tree mismatch");

     

       145
       145
       +
                     output = Printf.sprintf "Expected:\n%s\n\nActual:\n%s" expected_norm actual_norm;

     

       146
       146
       +
                   }

     

       147
       147
       +
               with exn ->

     

       148
       148
       +
                 { base with

     

       149
       149
       +
                   status = `Fail (Printf.sprintf "Exception: %s" (Printexc.to_string exn));

     

       150
       150
       +
                   output = Printexc.to_string exn;

     

       151
       151
       +
                 }

     

       152
       152
       +
         end

     

       153
       153
       +
       

     

       154
       154
       +
       let status_class = function

     

       155
       155
       +
         | `Pass -> "pass"

     

       156
       156
       +
         | `Fail _ -> "fail"

     

       157
       157
       +
         | `Skip -> "skip"

     

       158
       158
       +
       

     

       159
       159
       +
       let status_text = function

     

       160
       160
       +
         | `Pass -> "PASS"

     

       161
       161
       +
         | `Fail _ -> "FAIL"

     

       162
       162
       +
         | `Skip -> "SKIP"

     

       163
       163
       +
       

     

       164
       164
       +
       let generate_html results output_file =

     

       165
       165
       +
         let oc = open_out output_file in

     

       166
       166
       +
         let pass_count = List.length (List.filter (fun r -> r.status = `Pass) results) in

     

       167
       167
       +
         let fail_count = List.length (List.filter (fun r -> match r.status with `Fail _ -> true | _ -> false) results) in

     

       168
       168
       +
         let skip_count = List.length (List.filter (fun r -> r.status = `Skip) results) in

     

       169
       169
       +
         let total = List.length results in

     

       170
       170
       +
         let json_pass_count = List.length (List.filter (fun r -> r.json_status = `Pass) results) in

     

       171
       171
       +
         let json_fail_count = List.length (List.filter (fun r -> match r.json_status with `Fail _ -> true | _ -> false) results) in

     

       172
       172
       +
         let json_skip_count = List.length (List.filter (fun r -> r.json_status = `Skip) results) in

     

       173
       173
       +
       

     

       174
       174
       +
         Printf.fprintf oc {|<!DOCTYPE html>

     

       175
       175
       +
       <html lang="en">

     

       176
       176
       +
       <head>

     

       177
       177
       +
         <meta charset="UTF-8">

     

       178
       178
       +
         <meta name="viewport" content="width=device-width, initial-scale=1.0">

     

       179
       179
       +
         <title>Yamlrw Test Results</title>

     

       180
       180
       +
         <style>

     

       181
       181
       +
           :root {

     

       182
       182
       +
             --pass-color: #22c55e;

     

       183
       183
       +
             --fail-color: #ef4444;

     

       184
       184
       +
             --skip-color: #f59e0b;

     

       185
       185
       +
             --bg-color: #1a1a2e;

     

       186
       186
       +
             --card-bg: #16213e;

     

       187
       187
       +
             --text-color: #e2e8f0;

     

       188
       188
       +
             --border-color: #334155;

     

       189
       189
       +
           }

     

       190
       190
       +
           * { box-sizing: border-box; margin: 0; padding: 0; }

     

       191
       191
       +
           body {

     

       192
       192
       +
             font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;

     

       193
       193
       +
             background: var(--bg-color);

     

       194
       194
       +
             color: var(--text-color);

     

       195
       195
       +
             line-height: 1.6;

     

       196
       196
       +
             padding: 2rem;

     

       197
       197
       +
           }

     

       198
       198
       +
           .container { max-width: 1400px; margin: 0 auto; }

     

       199
       199
       +
           h1 { margin-bottom: 1.5rem; font-size: 2rem; }

     

       200
       200
       +
           .summary {

     

       201
       201
       +
             display: flex;

     

       202
       202
       +
             gap: 1rem;

     

       203
       203
       +
             margin-bottom: 2rem;

     

       204
       204
       +
             flex-wrap: wrap;

     

       205
       205
       +
           }

     

       206
       206
       +
           .stat {

     

       207
       207
       +
             background: var(--card-bg);

     

       208
       208
       +
             padding: 1rem 1.5rem;

     

       209
       209
       +
             border-radius: 8px;

     

       210
       210
       +
             border-left: 4px solid var(--border-color);

     

       211
       211
       +
           }

     

       212
       212
       +
           .stat.pass { border-left-color: var(--pass-color); }

     

       213
       213
       +
           .stat.fail { border-left-color: var(--fail-color); }

     

       214
       214
       +
           .stat.skip { border-left-color: var(--skip-color); }

     

       215
       215
       +
           .stat-value { font-size: 2rem; font-weight: bold; }

     

       216
       216
       +
           .stat-label { font-size: 0.875rem; opacity: 0.8; }

     

       217
       217
       +
           .filters {

     

       218
       218
       +
             margin-bottom: 1.5rem;

     

       219
       219
       +
             display: flex;

     

       220
       220
       +
             gap: 0.5rem;

     

       221
       221
       +
             flex-wrap: wrap;

     

       222
       222
       +
           }

     

       223
       223
       +
           .filter-btn {

     

       224
       224
       +
             padding: 0.5rem 1rem;

     

       225
       225
       +
             border: 1px solid var(--border-color);

     

       226
       226
       +
             background: var(--card-bg);

     

       227
       227
       +
             color: var(--text-color);

     

       228
       228
       +
             border-radius: 4px;

     

       229
       229
       +
             cursor: pointer;

     

       230
       230
       +
             transition: all 0.2s;

     

       231
       231
       +
           }

     

       232
       232
       +
           .filter-btn:hover { border-color: var(--text-color); }

     

       233
       233
       +
           .filter-btn.active { background: var(--text-color); color: var(--bg-color); }

     

       234
       234
       +
           .search {

     

       235
       235
       +
             padding: 0.5rem 1rem;

     

       236
       236
       +
             border: 1px solid var(--border-color);

     

       237
       237
       +
             background: var(--card-bg);

     

       238
       238
       +
             color: var(--text-color);

     

       239
       239
       +
             border-radius: 4px;

     

       240
       240
       +
             width: 200px;

     

       241
       241
       +
           }

     

       242
       242
       +
           .tests { display: flex; flex-direction: column; gap: 1rem; }

     

       243
       243
       +
           .test {

     

       244
       244
       +
             background: var(--card-bg);

     

       245
       245
       +
             border-radius: 8px;

     

       246
       246
       +
             border: 1px solid var(--border-color);

     

       247
       247
       +
             overflow: hidden;

     

       248
       248
       +
           }

     

       249
       249
       +
           .test-header {

     

       250
       250
       +
             padding: 1rem;

     

       251
       251
       +
             display: flex;

     

       252
       252
       +
             align-items: center;

     

       253
       253
       +
             gap: 1rem;

     

       254
       254
       +
             cursor: pointer;

     

       255
       255
       +
             border-bottom: 1px solid var(--border-color);

     

       256
       256
       +
           }

     

       257
       257
       +
           .test-header:hover { background: rgba(255,255,255,0.05); }

     

       258
       258
       +
           .badge {

     

       259
       259
       +
             padding: 0.25rem 0.5rem;

     

       260
       260
       +
             border-radius: 4px;

     

       261
       261
       +
             font-size: 0.75rem;

     

       262
       262
       +
             font-weight: bold;

     

       263
       263
       +
             text-transform: uppercase;

     

       264
       264
       +
           }

     

       265
       265
       +
           .badge.pass { background: var(--pass-color); color: #000; }

     

       266
       266
       +
           .badge.fail { background: var(--fail-color); color: #fff; }

     

       267
       267
       +
           .badge.skip { background: var(--skip-color); color: #000; }

     

       268
       268
       +
           .badge.error-test { background: #8b5cf6; color: #fff; margin-left: auto; }

     

       269
       269
       +
           .test-id { font-family: monospace; font-weight: bold; }

     

       270
       270
       +
           .test-name { opacity: 0.8; flex: 1; }

     

       271
       271
       +
           .test-content { display: none; padding: 1rem; }

     

       272
       272
       +
           .test.expanded .test-content { display: block; }

     

       273
       273
       +
           .section { margin-bottom: 1rem; }

     

       274
       274
       +
           .section-title {

     

       275
       275
       +
             font-size: 0.875rem;

     

       276
       276
       +
             text-transform: uppercase;

     

       277
       277
       +
             opacity: 0.6;

     

       278
       278
       +
             margin-bottom: 0.5rem;

     

       279
       279
       +
             letter-spacing: 0.05em;

     

       280
       280
       +
           }

     

       281
       281
       +
           pre {

     

       282
       282
       +
             background: #0f172a;

     

       283
       283
       +
             padding: 1rem;

     

       284
       284
       +
             border-radius: 4px;

     

       285
       285
       +
             overflow-x: auto;

     

       286
       286
       +
             font-size: 0.875rem;

     

       287
       287
       +
             white-space: pre-wrap;

     

       288
       288
       +
             word-break: break-all;

     

       289
       289
       +
           }

     

       290
       290
       +
           .expand-icon { transition: transform 0.2s; }

     

       291
       291
       +
           .test.expanded .expand-icon { transform: rotate(90deg); }

     

       292
       292
       +
         </style>

     

       293
       293
       +
       </head>

     

       294
       294
       +
       <body>

     

       295
       295
       +
         <div class="container">

     

       296
       296
       +
           <h1>Yamlrw Test Results</h1>

     

       297
       297
       +
           <div class="summary">

     

       298
       298
       +
             <div class="stat pass">

     

       299
       299
       +
               <div class="stat-value">%d</div>

     

       300
       300
       +
               <div class="stat-label">Passed</div>

     

       301
       301
       +
             </div>

     

       302
       302
       +
             <div class="stat fail">

     

       303
       303
       +
               <div class="stat-value">%d</div>

     

       304
       304
       +
               <div class="stat-label">Failed</div>

     

       305
       305
       +
             </div>

     

       306
       306
       +
             <div class="stat skip">

     

       307
       307
       +
               <div class="stat-value">%d</div>

     

       308
       308
       +
               <div class="stat-label">Skipped</div>

     

       309
       309
       +
             </div>

     

       310
       310
       +
             <div class="stat">

     

       311
       311
       +
               <div class="stat-value">%d</div>

     

       312
       312
       +
               <div class="stat-label">Total</div>

     

       313
       313
       +
             </div>

     

       314
       314
       +
           </div>

     

       315
       315
       +
           <h2 style="margin: 1.5rem 0 1rem;">JSON Output Comparison</h2>

     

       316
       316
       +
           <div class="summary">

     

       317
       317
       +
             <div class="stat pass">

     

       318
       318
       +
               <div class="stat-value">%d</div>

     

       319
       319
       +
               <div class="stat-label">JSON Pass</div>

     

       320
       320
       +
             </div>

     

       321
       321
       +
             <div class="stat fail">

     

       322
       322
       +
               <div class="stat-value">%d</div>

     

       323
       323
       +
               <div class="stat-label">JSON Fail</div>

     

       324
       324
       +
             </div>

     

       325
       325
       +
             <div class="stat skip">

     

       326
       326
       +
               <div class="stat-value">%d</div>

     

       327
       327
       +
               <div class="stat-label">JSON Skip</div>

     

       328
       328
       +
             </div>

     

       329
       329
       +
           </div>

     

       330
       330
       +
           <div class="filters">

     

       331
       331
       +
             <button class="filter-btn active" data-filter="all">All</button>

     

       332
       332
       +
             <button class="filter-btn" data-filter="pass">Pass</button>

     

       333
       333
       +
             <button class="filter-btn" data-filter="fail">Fail</button>

     

       334
       334
       +
             <button class="filter-btn" data-filter="skip">Skip</button>

     

       335
       335
       +
             <input type="text" class="search" placeholder="Search by ID or name...">

     

       336
       336
       +
           </div>

     

       337
       337
       +
           <div class="tests">

     

       338
       338
       +
       |} pass_count fail_count skip_count total json_pass_count json_fail_count json_skip_count;

     

       339
       339
       +
       

     

       340
       340
       +
         List.iter (fun result ->

     

       341
       341
       +
           let error_badge = if result.is_error_test then

     

       342
       342
       +
             {|<span class="badge error-test">Error Test</span>|}

     

       343
       343
       +
           else "" in

     

       344
       344
       +
           let json_badge = Printf.sprintf {|<span class="badge %s" style="margin-left: 4px;">JSON: %s</span>|}

     

       345
       345
       +
             (status_class result.json_status) (status_text result.json_status) in

     

       346
       346
       +
           let json_section = if result.json_expected <> "" || result.json_actual <> "" then

     

       347
       347
       +
             Printf.sprintf {|

     

       348
       348
       +
                 <div class="section">

     

       349
       349
       +
                   <div class="section-title">Expected JSON</div>

     

       350
       350
       +
                   <pre>%s</pre>

     

       351
       351
       +
                 </div>

     

       352
       352
       +
                 <div class="section">

     

       353
       353
       +
                   <div class="section-title">Actual JSON</div>

     

       354
       354
       +
                   <pre>%s</pre>

     

       355
       355
       +
                 </div>|}

     

       356
       356
       +
               (html_escape result.json_expected)

     

       357
       357
       +
               (html_escape result.json_actual)

     

       358
       358
       +
           else "" in

     

       359
       359
       +
           Printf.fprintf oc {|      <div class="test" data-status="%s" data-json-status="%s" data-id="%s" data-name="%s">

     

       360
       360
       +
               <div class="test-header" onclick="this.parentElement.classList.toggle('expanded')">

     

       361
       361
       +
                 <span class="expand-icon">▶</span>

     

       362
       362
       +
                 <span class="badge %s">%s</span>

     

       363
       363
       +
                 %s

     

       364
       364
       +
                 <span class="test-id">%s</span>

     

       365
       365
       +
                 <span class="test-name">%s</span>

     

       366
       366
       +
                 %s

     

       367
       367
       +
               </div>

     

       368
       368
       +
               <div class="test-content">

     

       369
       369
       +
                 <div class="section">

     

       370
       370
       +
                   <div class="section-title">YAML Input</div>

     

       371
       371
       +
                   <pre>%s</pre>

     

       372
       372
       +
                 </div>

     

       373
       373
       +
                 <div class="section">

     

       374
       374
       +
                   <div class="section-title">Event Tree Output</div>

     

       375
       375
       +
                   <pre>%s</pre>

     

       376
       376
       +
                 </div>%s

     

       377
       377
       +
               </div>

     

       378
       378
       +
             </div>

     

       379
       379
       +
       |}

     

       380
       380
       +
             (status_class result.status)

     

       381
       381
       +
             (status_class result.json_status)

     

       382
       382
       +
             (html_escape result.id)

     

       383
       383
       +
             (html_escape (String.lowercase_ascii result.name))

     

       384
       384
       +
             (status_class result.status)

     

       385
       385
       +
             (status_text result.status)

     

       386
       386
       +
             json_badge

     

       387
       387
       +
             (html_escape result.id)

     

       388
       388
       +
             (html_escape result.name)

     

       389
       389
       +
             error_badge

     

       390
       390
       +
             (html_escape result.yaml)

     

       391
       391
       +
             (html_escape result.output)

     

       392
       392
       +
             json_section

     

       393
       393
       +
         ) results;

     

       394
       394
       +
       

     

       395
       395
       +
         Printf.fprintf oc {|    </div>

     

       396
       396
       +
         </div>

     

       397
       397
       +
         <script>

     

       398
       398
       +
           document.querySelectorAll('.filter-btn').forEach(btn => {

     

       399
       399
       +
             btn.addEventListener('click', () => {

     

       400
       400
       +
               document.querySelectorAll('.filter-btn').forEach(b => b.classList.remove('active'));

     

       401
       401
       +
               btn.classList.add('active');

     

       402
       402
       +
               filterTests();

     

       403
       403
       +
             });

     

       404
       404
       +
           });

     

       405
       405
       +
           document.querySelector('.search').addEventListener('input', filterTests);

     

       406
       406
       +
           function filterTests() {

     

       407
       407
       +
             const filter = document.querySelector('.filter-btn.active').dataset.filter;

     

       408
       408
       +
             const search = document.querySelector('.search').value.toLowerCase();

     

       409
       409
       +
             document.querySelectorAll('.test').forEach(test => {

     

       410
       410
       +
               const status = test.dataset.status;

     

       411
       411
       +
               const id = test.dataset.id.toLowerCase();

     

       412
       412
       +
               const name = test.dataset.name;

     

       413
       413
       +
               const matchesFilter = filter === 'all' || status === filter;

     

       414
       414
       +
               const matchesSearch = !search || id.includes(search) || name.includes(search);

     

       415
       415
       +
               test.style.display = matchesFilter && matchesSearch ? '' : 'none';

     

       416
       416
       +
             });

     

       417
       417
       +
           }

     

       418
       418
       +
         </script>

     

       419
       419
       +
       </body>

     

       420
       420
       +
       </html>

     

       421
       421
       +
       |};

     

       422
       422
       +
         close_out oc

     

       423
       423
       +
       

     

       424
       424
       +
       let () =

     

       425
       425
       +
         let html_output = ref None in

     

       426
       426
       +
         let show_skipped = ref false in

     

       427
       427
       +
         let args = [

     

       428
       428
       +
           "--html", Arg.String (fun s -> html_output := Some s),

     

       429
       429
       +
           "<file> Generate HTML report to file";

     

       430
       430
       +
           "--show-skipped", Arg.Set show_skipped,

     

       431
       431
       +
           " Show details of skipped tests";

     

       432
       432
       +
         ] in

     

       433
       433
       +
         Arg.parse args (fun _ -> ()) "Usage: run_all_tests [--html <file>] [--show-skipped]";

     

       434
       434
       +
       

     

       435
       435
       +
         let all_tests = TL.load_directory test_suite_path in

     

       436
       436
       +
         Printf.printf "Total tests loaded: %d\n%!" (List.length all_tests);

     

       437
       437
       +
       

     

       438
       438
       +
         let results = List.map run_test all_tests in

     

       439
       439
       +
       

     

       440
       440
       +
         let pass_count = List.length (List.filter (fun r -> r.status = `Pass) results) in

     

       441
       441
       +
         let fail_count = List.length (List.filter (fun r -> match r.status with `Fail _ -> true | _ -> false) results) in

     

       442
       442
       +
         let skip_count = List.length (List.filter (fun r -> r.status = `Skip) results) in

     

       443
       443
       +
       

     

       444
       444
       +
         let json_pass_count = List.length (List.filter (fun r -> r.json_status = `Pass) results) in

     

       445
       445
       +
         let json_fail_count = List.length (List.filter (fun r -> match r.json_status with `Fail _ -> true | _ -> false) results) in

     

       446
       446
       +
         let json_skip_count = List.length (List.filter (fun r -> r.json_status = `Skip) results) in

     

       447
       447
       +
       

     

       448
       448
       +
         Printf.printf "\nEvent Tree Results: %d pass, %d fail, %d skip (total: %d)\n%!"

     

       449
       449
       +
           pass_count fail_count skip_count (pass_count + fail_count + skip_count);

     

       450
       450
       +
       

     

       451
       451
       +
         Printf.printf "JSON Results: %d pass, %d fail, %d skip\n%!"

     

       452
       452
       +
           json_pass_count json_fail_count json_skip_count;

     

       453
       453
       +
       

     

       454
       454
       +
         if fail_count > 0 then begin

     

       455
       455
       +
           Printf.printf "\nFailing event tree tests:\n";

     

       456
       456
       +
           List.iter (fun r ->

     

       457
       457
       +
             match r.status with

     

       458
       458
       +
             | `Fail msg -> Printf.printf "  %s: %s - %s\n" r.id r.name msg

     

       459
       459
       +
             | _ -> ()

     

       460
       460
       +
           ) results

     

       461
       461
       +
         end;

     

       462
       462
       +
       

     

       463
       463
       +
         if json_fail_count > 0 then begin

     

       464
       464
       +
           Printf.printf "\nFailing JSON tests:\n";

     

       465
       465
       +
           List.iter (fun r ->

     

       466
       466
       +
             match r.json_status with

     

       467
       467
       +
             | `Fail msg -> Printf.printf "  %s: %s - %s\n" r.id r.name msg

     

       468
       468
       +
             | _ -> ()

     

       469
       469
       +
           ) results

     

       470
       470
       +
         end;

     

       471
       471
       +
       

     

       472
       472
       +
         if !show_skipped && skip_count > 0 then begin

     

       473
       473
       +
           Printf.printf "\nSkipped tests (no expected tree):\n";

     

       474
       474
       +
           List.iter (fun r ->

     

       475
       475
       +
             if r.status = `Skip then begin

     

       476
       476
       +
               Printf.printf "  %s: %s\n" r.id r.name;

     

       477
       477
       +
               Printf.printf "    YAML (%d chars): %S\n" (String.length r.yaml)

     

       478
       478
       +
                 (if String.length r.yaml <= 60 then r.yaml

     

       479
       479
       +
                  else String.sub r.yaml 0 60 ^ "...")

     

       480
       480
       +
             end

     

       481
       481
       +
           ) results

     

       482
       482
       +
         end;

     

       483
       483
       +
       

     

       484
       484
       +
         match !html_output with

     

       485
       485
       +
         | Some file ->

     

       486
       486
       +
             generate_html results file;

     

       487
       487
       +
             Printf.printf "\nHTML report generated: %s\n" file

     

       488
       488
       +
         | None -> ()

+532

tests/run_all_tests_eio.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
       +
       (* Run the YAML test suite using Eio for parallel execution *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Yamlrw

     

       9
       9
       +
       module TL = Test_suite_lib_eio.Test_suite_loader_eio

     

       10
       10
       +
       module TF = Test_suite_lib.Tree_format

     

       11
       11
       +
       module JF = Test_suite_lib.Json_format

     

       12
       12
       +
       module JC = Test_suite_lib.Json_compare

     

       13
       13
       +
       

     

       14
       14
       +
       let test_suite_path = "../yaml-test-suite"

     

       15
       15
       +
       

     

       16
       16
       +
       (* HTML escape function *)

     

       17
       17
       +
       let html_escape s =

     

       18
       18
       +
         let buf = Buffer.create (String.length s) in

     

       19
       19
       +
         String.iter (function

     

       20
       20
       +
           | '<' -> Buffer.add_string buf "&lt;"

     

       21
       21
       +
           | '>' -> Buffer.add_string buf "&gt;"

     

       22
       22
       +
           | '&' -> Buffer.add_string buf "&amp;"

     

       23
       23
       +
           | '"' -> Buffer.add_string buf "&quot;"

     

       24
       24
       +
           | c -> Buffer.add_char buf c

     

       25
       25
       +
         ) s;

     

       26
       26
       +
         Buffer.contents buf

     

       27
       27
       +
       

     

       28
       28
       +
       let normalize_tree s =

     

       29
       29
       +
         let lines = String.split_on_char '\n' s in

     

       30
       30
       +
         let lines = List.filter (fun l -> String.trim l <> "") lines in

     

       31
       31
       +
         String.concat "\n" lines

     

       32
       32
       +
       

     

       33
       33
       +
       type test_result = {

     

       34
       34
       +
         id : string;

     

       35
       35
       +
         name : string;

     

       36
       36
       +
         yaml : string;

     

       37
       37
       +
         is_error_test : bool;

     

       38
       38
       +
         status : [`Pass | `Fail of string | `Skip];

     

       39
       39
       +
         output : string;

     

       40
       40
       +
         json_status : [`Pass | `Fail of string | `Skip];

     

       41
       41
       +
         json_expected : string;

     

       42
       42
       +
         json_actual : string;

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       let compare_json expected actual =

     

       46
       46
       +
         JC.compare_json_strings expected actual

     

       47
       47
       +
       

     

       48
       48
       +
       let run_json_test (test : TL.test_case) : [`Pass | `Fail of string | `Skip] * string =

     

       49
       49
       +
         match test.json with

     

       50
       50
       +
         | None -> (`Skip, "")

     

       51
       51
       +
         | Some expected_json ->

     

       52
       52
       +
             if test.fail then

     

       53
       53
       +
               (`Skip, "")

     

       54
       54
       +
             else

     

       55
       55
       +
               try

     

       56
       56
       +
                 let docs = Loader.documents_of_string test.yaml in

     

       57
       57
       +
                 let values = List.filter_map (fun doc ->

     

       58
       58
       +
                   match Document.root doc with

     

       59
       59
       +
                   | None -> None

     

       60
       60
       +
                   | Some yaml -> Some (Yaml.to_value ~resolve_aliases_first:true yaml)

     

       61
       61
       +
                 ) docs in

     

       62
       62
       +
                 let actual_json = match values with

     

       63
       63
       +
                   | [] -> ""

     

       64
       64
       +
                   | [v] -> JF.to_json v

     

       65
       65
       +
                   | vs -> JF.documents_to_json vs

     

       66
       66
       +
                 in

     

       67
       67
       +
                 if compare_json expected_json actual_json then

     

       68
       68
       +
                   (`Pass, actual_json)

     

       69
       69
       +
                 else

     

       70
       70
       +
                   (`Fail "JSON mismatch", actual_json)

     

       71
       71
       +
               with

     

       72
       72
       +
               | Yamlrw_error e ->

     

       73
       73
       +
                   (`Fail (Format.asprintf "Parse error: %a" Error.pp e), "")

     

       74
       74
       +
               | exn ->

     

       75
       75
       +
                   (`Fail (Printf.sprintf "Exception: %s" (Printexc.to_string exn)), "")

     

       76
       76
       +
       

     

       77
       77
       +
       let run_test (test : TL.test_case) : test_result =

     

       78
       78
       +
         let json_status, json_actual = run_json_test test in

     

       79
       79
       +
         let base = {

     

       80
       80
       +
           id = test.id;

     

       81
       81
       +
           name = test.name;

     

       82
       82
       +
           yaml = test.yaml;

     

       83
       83
       +
           is_error_test = test.fail;

     

       84
       84
       +
           status = `Skip;

     

       85
       85
       +
           output = "";

     

       86
       86
       +
           json_status;

     

       87
       87
       +
           json_expected = Option.value ~default:"" test.json;

     

       88
       88
       +
           json_actual;

     

       89
       89
       +
         } in

     

       90
       90
       +
         if test.fail then begin

     

       91
       91
       +
           try

     

       92
       92
       +
             let parser = Parser.of_string test.yaml in

     

       93
       93
       +
             let events = Parser.to_list parser in

     

       94
       94
       +
             let tree = TF.of_spanned_events events in

     

       95
       95
       +
             { base with

     

       96
       96
       +
               status = `Fail "Expected parsing to fail";

     

       97
       97
       +
               output = tree;

     

       98
       98
       +
             }

     

       99
       99
       +
           with

     

       100
       100
       +
           | Yamlrw_error e ->

     

       101
       101
       +
               { base with

     

       102
       102
       +
                 status = `Pass;

     

       103
       103
       +
                 output = Format.asprintf "%a" Error.pp e;

     

       104
       104
       +
               }

     

       105
       105
       +
           | exn ->

     

       106
       106
       +
               { base with

     

       107
       107
       +
                 status = `Pass;

     

       108
       108
       +
                 output = Printexc.to_string exn;

     

       109
       109
       +
               }

     

       110
       110
       +
         end

     

       111
       111
       +
         else begin

     

       112
       112
       +
           match test.tree with

     

       113
       113
       +
           | None ->

     

       114
       114
       +
               (match test.json with

     

       115
       115
       +
                | Some _ ->

     

       116
       116
       +
                    (try

     

       117
       117
       +
                      let parser = Parser.of_string test.yaml in

     

       118
       118
       +
                      let events = Parser.to_list parser in

     

       119
       119
       +
                      let tree = TF.of_spanned_events events in

     

       120
       120
       +
                      { base with status = `Pass; output = tree }

     

       121
       121
       +
                    with exn ->

     

       122
       122
       +
                      { base with

     

       123
       123
       +
                        status = `Fail (Printf.sprintf "Should parse but got: %s" (Printexc.to_string exn));

     

       124
       124
       +
                        output = Printexc.to_string exn;

     

       125
       125
       +
                      })

     

       126
       126
       +
                | None ->

     

       127
       127
       +
                    { base with status = `Skip; output = "(no expected tree or json)" })

     

       128
       128
       +
           | Some expected ->

     

       129
       129
       +
               try

     

       130
       130
       +
                 let parser = Parser.of_string test.yaml in

     

       131
       131
       +
                 let events = Parser.to_list parser in

     

       132
       132
       +
                 let actual = TF.of_spanned_events events in

     

       133
       133
       +
                 let expected_norm = normalize_tree expected in

     

       134
       134
       +
                 let actual_norm = normalize_tree actual in

     

       135
       135
       +
                 if expected_norm = actual_norm then

     

       136
       136
       +
                   { base with status = `Pass; output = actual }

     

       137
       137
       +
                 else

     

       138
       138
       +
                   { base with

     

       139
       139
       +
                     status = `Fail (Printf.sprintf "Tree mismatch");

     

       140
       140
       +
                     output = Printf.sprintf "Expected:\n%s\n\nActual:\n%s" expected_norm actual_norm;

     

       141
       141
       +
                   }

     

       142
       142
       +
               with exn ->

     

       143
       143
       +
                 { base with

     

       144
       144
       +
                   status = `Fail (Printf.sprintf "Exception: %s" (Printexc.to_string exn));

     

       145
       145
       +
                   output = Printexc.to_string exn;

     

       146
       146
       +
                 }

     

       147
       147
       +
         end

     

       148
       148
       +
       

     

       149
       149
       +
       (* Run tests in parallel using Eio fibers *)

     

       150
       150
       +
       let run_tests_parallel tests =

     

       151
       151
       +
         Eio.Fiber.List.map run_test tests

     

       152
       152
       +
       

     

       153
       153
       +
       let status_class = function

     

       154
       154
       +
         | `Pass -> "pass"

     

       155
       155
       +
         | `Fail _ -> "fail"

     

       156
       156
       +
         | `Skip -> "skip"

     

       157
       157
       +
       

     

       158
       158
       +
       let status_text = function

     

       159
       159
       +
         | `Pass -> "PASS"

     

       160
       160
       +
         | `Fail _ -> "FAIL"

     

       161
       161
       +
         | `Skip -> "SKIP"

     

       162
       162
       +
       

     

       163
       163
       +
       let generate_html ~fs results output_file =

     

       164
       164
       +
         let pass_count = List.length (List.filter (fun r -> r.status = `Pass) results) in

     

       165
       165
       +
         let fail_count = List.length (List.filter (fun r -> match r.status with `Fail _ -> true | _ -> false) results) in

     

       166
       166
       +
         let skip_count = List.length (List.filter (fun r -> r.status = `Skip) results) in

     

       167
       167
       +
         let total = List.length results in

     

       168
       168
       +
         let json_pass_count = List.length (List.filter (fun r -> r.json_status = `Pass) results) in

     

       169
       169
       +
         let json_fail_count = List.length (List.filter (fun r -> match r.json_status with `Fail _ -> true | _ -> false) results) in

     

       170
       170
       +
         let json_skip_count = List.length (List.filter (fun r -> r.json_status = `Skip) results) in

     

       171
       171
       +
       

     

       172
       172
       +
         let buf = Buffer.create 65536 in

     

       173
       173
       +
         Printf.bprintf buf {|<!DOCTYPE html>

     

       174
       174
       +
       <html lang="en">

     

       175
       175
       +
       <head>

     

       176
       176
       +
         <meta charset="UTF-8">

     

       177
       177
       +
         <meta name="viewport" content="width=device-width, initial-scale=1.0">

     

       178
       178
       +
         <title>Yamlrw Test Results (Eio)</title>

     

       179
       179
       +
         <style>

     

       180
       180
       +
           :root {

     

       181
       181
       +
             --pass-color: #22c55e;

     

       182
       182
       +
             --fail-color: #ef4444;

     

       183
       183
       +
             --skip-color: #f59e0b;

     

       184
       184
       +
             --bg-color: #1a1a2e;

     

       185
       185
       +
             --card-bg: #16213e;

     

       186
       186
       +
             --text-color: #e2e8f0;

     

       187
       187
       +
             --border-color: #334155;

     

       188
       188
       +
           }

     

       189
       189
       +
           * { box-sizing: border-box; margin: 0; padding: 0; }

     

       190
       190
       +
           body {

     

       191
       191
       +
             font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;

     

       192
       192
       +
             background: var(--bg-color);

     

       193
       193
       +
             color: var(--text-color);

     

       194
       194
       +
             line-height: 1.6;

     

       195
       195
       +
             padding: 2rem;

     

       196
       196
       +
           }

     

       197
       197
       +
           .container { max-width: 1400px; margin: 0 auto; }

     

       198
       198
       +
           h1 { margin-bottom: 1.5rem; font-size: 2rem; }

     

       199
       199
       +
           .eio-badge {

     

       200
       200
       +
             display: inline-block;

     

       201
       201
       +
             background: linear-gradient(135deg, #667eea 0%%, #764ba2 100%%);

     

       202
       202
       +
             color: white;

     

       203
       203
       +
             padding: 0.25rem 0.75rem;

     

       204
       204
       +
             border-radius: 999px;

     

       205
       205
       +
             font-size: 0.875rem;

     

       206
       206
       +
             margin-left: 1rem;

     

       207
       207
       +
             vertical-align: middle;

     

       208
       208
       +
           }

     

       209
       209
       +
           .summary {

     

       210
       210
       +
             display: flex;

     

       211
       211
       +
             gap: 1rem;

     

       212
       212
       +
             margin-bottom: 2rem;

     

       213
       213
       +
             flex-wrap: wrap;

     

       214
       214
       +
           }

     

       215
       215
       +
           .stat {

     

       216
       216
       +
             background: var(--card-bg);

     

       217
       217
       +
             padding: 1rem 1.5rem;

     

       218
       218
       +
             border-radius: 8px;

     

       219
       219
       +
             border-left: 4px solid var(--border-color);

     

       220
       220
       +
           }

     

       221
       221
       +
           .stat.pass { border-left-color: var(--pass-color); }

     

       222
       222
       +
           .stat.fail { border-left-color: var(--fail-color); }

     

       223
       223
       +
           .stat.skip { border-left-color: var(--skip-color); }

     

       224
       224
       +
           .stat-value { font-size: 2rem; font-weight: bold; }

     

       225
       225
       +
           .stat-label { font-size: 0.875rem; opacity: 0.8; }

     

       226
       226
       +
           .filters {

     

       227
       227
       +
             margin-bottom: 1.5rem;

     

       228
       228
       +
             display: flex;

     

       229
       229
       +
             gap: 0.5rem;

     

       230
       230
       +
             flex-wrap: wrap;

     

       231
       231
       +
           }

     

       232
       232
       +
           .filter-btn {

     

       233
       233
       +
             padding: 0.5rem 1rem;

     

       234
       234
       +
             border: 1px solid var(--border-color);

     

       235
       235
       +
             background: var(--card-bg);

     

       236
       236
       +
             color: var(--text-color);

     

       237
       237
       +
             border-radius: 4px;

     

       238
       238
       +
             cursor: pointer;

     

       239
       239
       +
             transition: all 0.2s;

     

       240
       240
       +
           }

     

       241
       241
       +
           .filter-btn:hover { border-color: var(--text-color); }

     

       242
       242
       +
           .filter-btn.active { background: var(--text-color); color: var(--bg-color); }

     

       243
       243
       +
           .search {

     

       244
       244
       +
             padding: 0.5rem 1rem;

     

       245
       245
       +
             border: 1px solid var(--border-color);

     

       246
       246
       +
             background: var(--card-bg);

     

       247
       247
       +
             color: var(--text-color);

     

       248
       248
       +
             border-radius: 4px;

     

       249
       249
       +
             width: 200px;

     

       250
       250
       +
           }

     

       251
       251
       +
           .tests { display: flex; flex-direction: column; gap: 1rem; }

     

       252
       252
       +
           .test {

     

       253
       253
       +
             background: var(--card-bg);

     

       254
       254
       +
             border-radius: 8px;

     

       255
       255
       +
             border: 1px solid var(--border-color);

     

       256
       256
       +
             overflow: hidden;

     

       257
       257
       +
           }

     

       258
       258
       +
           .test-header {

     

       259
       259
       +
             padding: 1rem;

     

       260
       260
       +
             display: flex;

     

       261
       261
       +
             align-items: center;

     

       262
       262
       +
             gap: 1rem;

     

       263
       263
       +
             cursor: pointer;

     

       264
       264
       +
             border-bottom: 1px solid var(--border-color);

     

       265
       265
       +
           }

     

       266
       266
       +
           .test-header:hover { background: rgba(255,255,255,0.05); }

     

       267
       267
       +
           .badge {

     

       268
       268
       +
             padding: 0.25rem 0.5rem;

     

       269
       269
       +
             border-radius: 4px;

     

       270
       270
       +
             font-size: 0.75rem;

     

       271
       271
       +
             font-weight: bold;

     

       272
       272
       +
             text-transform: uppercase;

     

       273
       273
       +
           }

     

       274
       274
       +
           .badge.pass { background: var(--pass-color); color: #000; }

     

       275
       275
       +
           .badge.fail { background: var(--fail-color); color: #fff; }

     

       276
       276
       +
           .badge.skip { background: var(--skip-color); color: #000; }

     

       277
       277
       +
           .badge.error-test { background: #8b5cf6; color: #fff; margin-left: auto; }

     

       278
       278
       +
           .test-id { font-family: monospace; font-weight: bold; }

     

       279
       279
       +
           .test-name { opacity: 0.8; flex: 1; }

     

       280
       280
       +
           .test-content { display: none; padding: 1rem; }

     

       281
       281
       +
           .test.expanded .test-content { display: block; }

     

       282
       282
       +
           .section { margin-bottom: 1rem; }

     

       283
       283
       +
           .section-title {

     

       284
       284
       +
             font-size: 0.875rem;

     

       285
       285
       +
             text-transform: uppercase;

     

       286
       286
       +
             opacity: 0.6;

     

       287
       287
       +
             margin-bottom: 0.5rem;

     

       288
       288
       +
             letter-spacing: 0.05em;

     

       289
       289
       +
           }

     

       290
       290
       +
           pre {

     

       291
       291
       +
             background: #0f172a;

     

       292
       292
       +
             padding: 1rem;

     

       293
       293
       +
             border-radius: 4px;

     

       294
       294
       +
             overflow-x: auto;

     

       295
       295
       +
             font-size: 0.875rem;

     

       296
       296
       +
             white-space: pre-wrap;

     

       297
       297
       +
             word-break: break-all;

     

       298
       298
       +
           }

     

       299
       299
       +
           .expand-icon { transition: transform 0.2s; }

     

       300
       300
       +
           .test.expanded .expand-icon { transform: rotate(90deg); }

     

       301
       301
       +
         </style>

     

       302
       302
       +
       </head>

     

       303
       303
       +
       <body>

     

       304
       304
       +
         <div class="container">

     

       305
       305
       +
           <h1>Yamlrw Test Results <span class="eio-badge">Eio Parallel</span></h1>

     

       306
       306
       +
           <div class="summary">

     

       307
       307
       +
             <div class="stat pass">

     

       308
       308
       +
               <div class="stat-value">%d</div>

     

       309
       309
       +
               <div class="stat-label">Passed</div>

     

       310
       310
       +
             </div>

     

       311
       311
       +
             <div class="stat fail">

     

       312
       312
       +
               <div class="stat-value">%d</div>

     

       313
       313
       +
               <div class="stat-label">Failed</div>

     

       314
       314
       +
             </div>

     

       315
       315
       +
             <div class="stat skip">

     

       316
       316
       +
               <div class="stat-value">%d</div>

     

       317
       317
       +
               <div class="stat-label">Skipped</div>

     

       318
       318
       +
             </div>

     

       319
       319
       +
             <div class="stat">

     

       320
       320
       +
               <div class="stat-value">%d</div>

     

       321
       321
       +
               <div class="stat-label">Total</div>

     

       322
       322
       +
             </div>

     

       323
       323
       +
           </div>

     

       324
       324
       +
           <h2 style="margin: 1.5rem 0 1rem;">JSON Output Comparison</h2>

     

       325
       325
       +
           <div class="summary">

     

       326
       326
       +
             <div class="stat pass">

     

       327
       327
       +
               <div class="stat-value">%d</div>

     

       328
       328
       +
               <div class="stat-label">JSON Pass</div>

     

       329
       329
       +
             </div>

     

       330
       330
       +
             <div class="stat fail">

     

       331
       331
       +
               <div class="stat-value">%d</div>

     

       332
       332
       +
               <div class="stat-label">JSON Fail</div>

     

       333
       333
       +
             </div>

     

       334
       334
       +
             <div class="stat skip">

     

       335
       335
       +
               <div class="stat-value">%d</div>

     

       336
       336
       +
               <div class="stat-label">JSON Skip</div>

     

       337
       337
       +
             </div>

     

       338
       338
       +
           </div>

     

       339
       339
       +
           <div class="filters">

     

       340
       340
       +
             <button class="filter-btn active" data-filter="all">All</button>

     

       341
       341
       +
             <button class="filter-btn" data-filter="pass">Pass</button>

     

       342
       342
       +
             <button class="filter-btn" data-filter="fail">Fail</button>

     

       343
       343
       +
             <button class="filter-btn" data-filter="skip">Skip</button>

     

       344
       344
       +
             <input type="text" class="search" placeholder="Search by ID or name...">

     

       345
       345
       +
           </div>

     

       346
       346
       +
           <div class="tests">

     

       347
       347
       +
       |} pass_count fail_count skip_count total json_pass_count json_fail_count json_skip_count;

     

       348
       348
       +
       

     

       349
       349
       +
         List.iter (fun result ->

     

       350
       350
       +
           let error_badge = if result.is_error_test then

     

       351
       351
       +
             {|<span class="badge error-test">Error Test</span>|}

     

       352
       352
       +
           else "" in

     

       353
       353
       +
           let json_badge = Printf.sprintf {|<span class="badge %s" style="margin-left: 4px;">JSON: %s</span>|}

     

       354
       354
       +
             (status_class result.json_status) (status_text result.json_status) in

     

       355
       355
       +
           let json_section = if result.json_expected <> "" || result.json_actual <> "" then

     

       356
       356
       +
             Printf.sprintf {|

     

       357
       357
       +
                 <div class="section">

     

       358
       358
       +
                   <div class="section-title">Expected JSON</div>

     

       359
       359
       +
                   <pre>%s</pre>

     

       360
       360
       +
                 </div>

     

       361
       361
       +
                 <div class="section">

     

       362
       362
       +
                   <div class="section-title">Actual JSON</div>

     

       363
       363
       +
                   <pre>%s</pre>

     

       364
       364
       +
                 </div>|}

     

       365
       365
       +
               (html_escape result.json_expected)

     

       366
       366
       +
               (html_escape result.json_actual)

     

       367
       367
       +
           else "" in

     

       368
       368
       +
           Printf.bprintf buf {|      <div class="test" data-status="%s" data-json-status="%s" data-id="%s" data-name="%s">

     

       369
       369
       +
               <div class="test-header" onclick="this.parentElement.classList.toggle('expanded')">

     

       370
       370
       +
                 <span class="expand-icon">▶</span>

     

       371
       371
       +
                 <span class="badge %s">%s</span>

     

       372
       372
       +
                 %s

     

       373
       373
       +
                 <span class="test-id">%s</span>

     

       374
       374
       +
                 <span class="test-name">%s</span>

     

       375
       375
       +
                 %s

     

       376
       376
       +
               </div>

     

       377
       377
       +
               <div class="test-content">

     

       378
       378
       +
                 <div class="section">

     

       379
       379
       +
                   <div class="section-title">YAML Input</div>

     

       380
       380
       +
                   <pre>%s</pre>

     

       381
       381
       +
                 </div>

     

       382
       382
       +
                 <div class="section">

     

       383
       383
       +
                   <div class="section-title">Event Tree Output</div>

     

       384
       384
       +
                   <pre>%s</pre>

     

       385
       385
       +
                 </div>%s

     

       386
       386
       +
               </div>

     

       387
       387
       +
             </div>

     

       388
       388
       +
       |}

     

       389
       389
       +
             (status_class result.status)

     

       390
       390
       +
             (status_class result.json_status)

     

       391
       391
       +
             (html_escape result.id)

     

       392
       392
       +
             (html_escape (String.lowercase_ascii result.name))

     

       393
       393
       +
             (status_class result.status)

     

       394
       394
       +
             (status_text result.status)

     

       395
       395
       +
             json_badge

     

       396
       396
       +
             (html_escape result.id)

     

       397
       397
       +
             (html_escape result.name)

     

       398
       398
       +
             error_badge

     

       399
       399
       +
             (html_escape result.yaml)

     

       400
       400
       +
             (html_escape result.output)

     

       401
       401
       +
             json_section

     

       402
       402
       +
         ) results;

     

       403
       403
       +
       

     

       404
       404
       +
         Printf.bprintf buf {|    </div>

     

       405
       405
       +
         </div>

     

       406
       406
       +
         <script>

     

       407
       407
       +
           document.querySelectorAll('.filter-btn').forEach(btn => {

     

       408
       408
       +
             btn.addEventListener('click', () => {

     

       409
       409
       +
               document.querySelectorAll('.filter-btn').forEach(b => b.classList.remove('active'));

     

       410
       410
       +
               btn.classList.add('active');

     

       411
       411
       +
               filterTests();

     

       412
       412
       +
             });

     

       413
       413
       +
           });

     

       414
       414
       +
           document.querySelector('.search').addEventListener('input', filterTests);

     

       415
       415
       +
           function filterTests() {

     

       416
       416
       +
             const filter = document.querySelector('.filter-btn.active').dataset.filter;

     

       417
       417
       +
             const search = document.querySelector('.search').value.toLowerCase();

     

       418
       418
       +
             document.querySelectorAll('.test').forEach(test => {

     

       419
       419
       +
               const status = test.dataset.status;

     

       420
       420
       +
               const id = test.dataset.id.toLowerCase();

     

       421
       421
       +
               const name = test.dataset.name;

     

       422
       422
       +
               const matchesFilter = filter === 'all' || status === filter;

     

       423
       423
       +
               const matchesSearch = !search || id.includes(search) || name.includes(search);

     

       424
       424
       +
               test.style.display = matchesFilter && matchesSearch ? '' : 'none';

     

       425
       425
       +
             });

     

       426
       426
       +
           }

     

       427
       427
       +
         </script>

     

       428
       428
       +
       </body>

     

       429
       429
       +
       </html>

     

       430
       430
       +
       |};

     

       431
       431
       +
       

     

       432
       432
       +
         Eio.Path.save ~create:(`Or_truncate 0o644)

     

       433
       433
       +
           Eio.Path.(fs / output_file)

     

       434
       434
       +
           (Buffer.contents buf)

     

       435
       435
       +
       

     

       436
       436
       +
       let () =

     

       437
       437
       +
         let html_output = ref None in

     

       438
       438
       +
         let show_skipped = ref false in

     

       439
       439
       +
         let sequential = ref false in

     

       440
       440
       +
         let args = [

     

       441
       441
       +
           "--html", Arg.String (fun s -> html_output := Some s),

     

       442
       442
       +
           "<file> Generate HTML report to file";

     

       443
       443
       +
           "--show-skipped", Arg.Set show_skipped,

     

       444
       444
       +
           " Show details of skipped tests";

     

       445
       445
       +
           "--sequential", Arg.Set sequential,

     

       446
       446
       +
           " Run tests sequentially instead of in parallel";

     

       447
       447
       +
         ] in

     

       448
       448
       +
         Arg.parse args (fun _ -> ()) "Usage: run_all_tests_eio [--html <file>] [--show-skipped] [--sequential]";

     

       449
       449
       +
       

     

       450
       450
       +
         Eio_main.run @@ fun env ->

     

       451
       451
       +
         (* Use fs (full filesystem) rather than cwd (sandboxed) to allow ".." navigation *)

     

       452
       452
       +
         let fs = Eio.Stdenv.fs env in

     

       453
       453
       +
         (* Get the absolute path to the test suite *)

     

       454
       454
       +
         let cwd = Sys.getcwd () in

     

       455
       455
       +
         let test_suite_abs = if Filename.is_relative test_suite_path then

     

       456
       456
       +
           Filename.concat cwd test_suite_path

     

       457
       457
       +
         else

     

       458
       458
       +
           test_suite_path

     

       459
       459
       +
         in

     

       460
       460
       +
       

     

       461
       461
       +
         let start_time = Unix.gettimeofday () in

     

       462
       462
       +
       

     

       463
       463
       +
         (* Load tests using Eio (parallel by default) *)

     

       464
       464
       +
         let all_tests = if !sequential then

     

       465
       465
       +
           TL.load_directory ~fs test_suite_abs

     

       466
       466
       +
         else

     

       467
       467
       +
           TL.load_directory_parallel ~fs test_suite_abs

     

       468
       468
       +
         in

     

       469
       469
       +
         let load_time = Unix.gettimeofday () in

     

       470
       470
       +
         Printf.printf "Loaded %d tests in %.3fs\n%!" (List.length all_tests) (load_time -. start_time);

     

       471
       471
       +
       

     

       472
       472
       +
         (* Run tests (parallel or sequential based on flag) *)

     

       473
       473
       +
         let results = if !sequential then

     

       474
       474
       +
           List.map run_test all_tests

     

       475
       475
       +
         else

     

       476
       476
       +
           run_tests_parallel all_tests

     

       477
       477
       +
         in

     

       478
       478
       +
         let run_time = Unix.gettimeofday () in

     

       479
       479
       +
         Printf.printf "Ran tests in %.3fs\n%!" (run_time -. load_time);

     

       480
       480
       +
       

     

       481
       481
       +
         let pass_count = List.length (List.filter (fun r -> r.status = `Pass) results) in

     

       482
       482
       +
         let fail_count = List.length (List.filter (fun r -> match r.status with `Fail _ -> true | _ -> false) results) in

     

       483
       483
       +
         let skip_count = List.length (List.filter (fun r -> r.status = `Skip) results) in

     

       484
       484
       +
       

     

       485
       485
       +
         let json_pass_count = List.length (List.filter (fun r -> r.json_status = `Pass) results) in

     

       486
       486
       +
         let json_fail_count = List.length (List.filter (fun r -> match r.json_status with `Fail _ -> true | _ -> false) results) in

     

       487
       487
       +
         let json_skip_count = List.length (List.filter (fun r -> r.json_status = `Skip) results) in

     

       488
       488
       +
       

     

       489
       489
       +
         Printf.printf "\nEvent Tree Results: %d pass, %d fail, %d skip (total: %d)\n%!"

     

       490
       490
       +
           pass_count fail_count skip_count (pass_count + fail_count + skip_count);

     

       491
       491
       +
       

     

       492
       492
       +
         Printf.printf "JSON Results: %d pass, %d fail, %d skip\n%!"

     

       493
       493
       +
           json_pass_count json_fail_count json_skip_count;

     

       494
       494
       +
       

     

       495
       495
       +
         if fail_count > 0 then begin

     

       496
       496
       +
           Printf.printf "\nFailing event tree tests:\n";

     

       497
       497
       +
           List.iter (fun r ->

     

       498
       498
       +
             match r.status with

     

       499
       499
       +
             | `Fail msg -> Printf.printf "  %s: %s - %s\n" r.id r.name msg

     

       500
       500
       +
             | _ -> ()

     

       501
       501
       +
           ) results

     

       502
       502
       +
         end;

     

       503
       503
       +
       

     

       504
       504
       +
         if json_fail_count > 0 then begin

     

       505
       505
       +
           Printf.printf "\nFailing JSON tests:\n";

     

       506
       506
       +
           List.iter (fun r ->

     

       507
       507
       +
             match r.json_status with

     

       508
       508
       +
             | `Fail msg -> Printf.printf "  %s: %s - %s\n" r.id r.name msg

     

       509
       509
       +
             | _ -> ()

     

       510
       510
       +
           ) results

     

       511
       511
       +
         end;

     

       512
       512
       +
       

     

       513
       513
       +
         if !show_skipped && skip_count > 0 then begin

     

       514
       514
       +
           Printf.printf "\nSkipped tests (no expected tree):\n";

     

       515
       515
       +
           List.iter (fun r ->

     

       516
       516
       +
             if r.status = `Skip then begin

     

       517
       517
       +
               Printf.printf "  %s: %s\n" r.id r.name;

     

       518
       518
       +
               Printf.printf "    YAML (%d chars): %S\n" (String.length r.yaml)

     

       519
       519
       +
                 (if String.length r.yaml <= 60 then r.yaml

     

       520
       520
       +
                  else String.sub r.yaml 0 60 ^ "...")

     

       521
       521
       +
             end

     

       522
       522
       +
           ) results

     

       523
       523
       +
         end;

     

       524
       524
       +
       

     

       525
       525
       +
         let total_time = Unix.gettimeofday () in

     

       526
       526
       +
         Printf.printf "\nTotal time: %.3fs\n%!" (total_time -. start_time);

     

       527
       527
       +
       

     

       528
       528
       +
         match !html_output with

     

       529
       529
       +
         | Some file ->

     

       530
       530
       +
             generate_html ~fs results file;

     

       531
       531
       +
             Printf.printf "HTML report generated: %s\n" file

     

       532
       532
       +
         | None -> ()

tests/test_suite_lib/dune

···

       1
       1
       +
       (library

     

       2
       2
       +
        (name test_suite_lib)

     

       3
       3
       +
        (modules test_suite_loader_generic test_suite_loader tree_format json_format json_compare)

     

       4
       4
       +
        (libraries yamlrw jsonm))

     

       5
       5
       +
       

     

       6
       6
       +
       (library

     

       7
       7
       +
        (name test_suite_lib_eio)

     

       8
       8
       +
        (modules test_suite_loader_eio)

     

       9
       9
       +
        (libraries test_suite_lib eio))

+146

tests/test_suite_lib/json_compare.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
       +
       (* Parse JSON using jsonm and compare parsed structures *)

     

       7
       7
       +
       

     

       8
       8
       +
       type json =

     

       9
       9
       +
         | Null

     

       10
       10
       +
         | Bool of bool

     

       11
       11
       +
         | Float of float

     

       12
       12
       +
         | String of string

     

       13
       13
       +
         | Array of json list

     

       14
       14
       +
         | Object of (string * json) list

     

       15
       15
       +
       

     

       16
       16
       +
       let rec equal a b =

     

       17
       17
       +
         match a, b with

     

       18
       18
       +
         | Null, Null -> true

     

       19
       19
       +
         | Bool a, Bool b -> a = b

     

       20
       20
       +
         | Float a, Float b -> Float.equal a b

     

       21
       21
       +
         | String a, String b -> String.equal a b

     

       22
       22
       +
         | Array a, Array b -> List.equal equal a b

     

       23
       23
       +
         | Object a, Object b ->

     

       24
       24
       +
             (* Compare objects as sets of key-value pairs (order independent) *)

     

       25
       25
       +
             let sorted_a = List.sort (fun (k1, _) (k2, _) -> String.compare k1 k2) a in

     

       26
       26
       +
             let sorted_b = List.sort (fun (k1, _) (k2, _) -> String.compare k1 k2) b in

     

       27
       27
       +
             List.length sorted_a = List.length sorted_b &&

     

       28
       28
       +
             List.for_all2 (fun (k1, v1) (k2, v2) -> k1 = k2 && equal v1 v2) sorted_a sorted_b

     

       29
       29
       +
         | _ -> false

     

       30
       30
       +
       

     

       31
       31
       +
       (* Parse JSON string using jsonm *)

     

       32
       32
       +
       let parse_json s =

     

       33
       33
       +
         let decoder = Jsonm.decoder (`String s) in

     

       34
       34
       +
         let rec parse_value () =

     

       35
       35
       +
           match Jsonm.decode decoder with

     

       36
       36
       +
           | `Lexeme `Null -> Ok Null

     

       37
       37
       +
           | `Lexeme (`Bool b) -> Ok (Bool b)

     

       38
       38
       +
           | `Lexeme (`Float f) -> Ok (Float f)

     

       39
       39
       +
           | `Lexeme (`String s) -> Ok (String s)

     

       40
       40
       +
           | `Lexeme `As -> parse_array []

     

       41
       41
       +
           | `Lexeme `Os -> parse_object []

     

       42
       42
       +
           | `Lexeme _ -> Error "unexpected lexeme"

     

       43
       43
       +
           | `Error e -> Error (Format.asprintf "%a" Jsonm.pp_error e)

     

       44
       44
       +
           | `End -> Error "unexpected end"

     

       45
       45
       +
           | `Await -> Error "unexpected await"

     

       46
       46
       +
         and parse_array acc =

     

       47
       47
       +
           match Jsonm.decode decoder with

     

       48
       48
       +
           | `Lexeme `Ae -> Ok (Array (List.rev acc))

     

       49
       49
       +
           | `Lexeme _ as lex ->

     

       50
       50
       +
               (* Push back and parse value *)

     

       51
       51
       +
               let result = parse_value_with_lex lex in

     

       52
       52
       +
               (match result with

     

       53
       53
       +
                | Ok v -> parse_array (v :: acc)

     

       54
       54
       +
                | Error _ as e -> e)

     

       55
       55
       +
           | `Error e -> Error (Format.asprintf "%a" Jsonm.pp_error e)

     

       56
       56
       +
           | `End -> Error "unexpected end in array"

     

       57
       57
       +
           | `Await -> Error "unexpected await"

     

       58
       58
       +
         and parse_object acc =

     

       59
       59
       +
           match Jsonm.decode decoder with

     

       60
       60
       +
           | `Lexeme `Oe -> Ok (Object (List.rev acc))

     

       61
       61
       +
           | `Lexeme (`Name key) ->

     

       62
       62
       +
               (match parse_value () with

     

       63
       63
       +
                | Ok v -> parse_object ((key, v) :: acc)

     

       64
       64
       +
                | Error _ as e -> e)

     

       65
       65
       +
           | `Lexeme _ -> Error "expected object key"

     

       66
       66
       +
           | `Error e -> Error (Format.asprintf "%a" Jsonm.pp_error e)

     

       67
       67
       +
           | `End -> Error "unexpected end in object"

     

       68
       68
       +
           | `Await -> Error "unexpected await"

     

       69
       69
       +
         and parse_value_with_lex lex =

     

       70
       70
       +
           match lex with

     

       71
       71
       +
           | `Lexeme `Null -> Ok Null

     

       72
       72
       +
           | `Lexeme (`Bool b) -> Ok (Bool b)

     

       73
       73
       +
           | `Lexeme (`Float f) -> Ok (Float f)

     

       74
       74
       +
           | `Lexeme (`String s) -> Ok (String s)

     

       75
       75
       +
           | `Lexeme `As -> parse_array []

     

       76
       76
       +
           | `Lexeme `Os -> parse_object []

     

       77
       77
       +
           | `Lexeme _ -> Error "unexpected lexeme"

     

       78
       78
       +
           | `Error e -> Error (Format.asprintf "%a" Jsonm.pp_error e)

     

       79
       79
       +
           | `End -> Error "unexpected end"

     

       80
       80
       +
           | `Await -> Error "unexpected await"

     

       81
       81
       +
         in

     

       82
       82
       +
         parse_value ()

     

       83
       83
       +
       

     

       84
       84
       +
       (* Parse multiple JSON values (for multi-document YAML) *)

     

       85
       85
       +
       let parse_json_multi s =

     

       86
       86
       +
         let decoder = Jsonm.decoder (`String s) in

     

       87
       87
       +
         let rec parse_value () =

     

       88
       88
       +
           match Jsonm.decode decoder with

     

       89
       89
       +
           | `Lexeme `Null -> Some Null

     

       90
       90
       +
           | `Lexeme (`Bool b) -> Some (Bool b)

     

       91
       91
       +
           | `Lexeme (`Float f) -> Some (Float f)

     

       92
       92
       +
           | `Lexeme (`String s) -> Some (String s)

     

       93
       93
       +
           | `Lexeme `As -> parse_array []

     

       94
       94
       +
           | `Lexeme `Os -> parse_object []

     

       95
       95
       +
           | `Lexeme _ -> None

     

       96
       96
       +
           | `Error _ -> None

     

       97
       97
       +
           | `End -> None

     

       98
       98
       +
           | `Await -> None

     

       99
       99
       +
         and parse_array acc =

     

       100
       100
       +
           match Jsonm.decode decoder with

     

       101
       101
       +
           | `Lexeme `Ae -> Some (Array (List.rev acc))

     

       102
       102
       +
           | `Lexeme _ as lex ->

     

       103
       103
       +
               (match parse_value_with_lex lex with

     

       104
       104
       +
                | Some v -> parse_array (v :: acc)

     

       105
       105
       +
                | None -> None)

     

       106
       106
       +
           | _ -> None

     

       107
       107
       +
         and parse_object acc =

     

       108
       108
       +
           match Jsonm.decode decoder with

     

       109
       109
       +
           | `Lexeme `Oe -> Some (Object (List.rev acc))

     

       110
       110
       +
           | `Lexeme (`Name key) ->

     

       111
       111
       +
               (match parse_value () with

     

       112
       112
       +
                | Some v -> parse_object ((key, v) :: acc)

     

       113
       113
       +
                | None -> None)

     

       114
       114
       +
           | _ -> None

     

       115
       115
       +
         and parse_value_with_lex lex =

     

       116
       116
       +
           match lex with

     

       117
       117
       +
           | `Lexeme `Null -> Some Null

     

       118
       118
       +
           | `Lexeme (`Bool b) -> Some (Bool b)

     

       119
       119
       +
           | `Lexeme (`Float f) -> Some (Float f)

     

       120
       120
       +
           | `Lexeme (`String s) -> Some (String s)

     

       121
       121
       +
           | `Lexeme `As -> parse_array []

     

       122
       122
       +
           | `Lexeme `Os -> parse_object []

     

       123
       123
       +
           | _ -> None

     

       124
       124
       +
         in

     

       125
       125
       +
         let rec collect acc =

     

       126
       126
       +
           match parse_value () with

     

       127
       127
       +
           | Some v -> collect (v :: acc)

     

       128
       128
       +
           | None -> List.rev acc

     

       129
       129
       +
         in

     

       130
       130
       +
         collect []

     

       131
       131
       +
       

     

       132
       132
       +
       (* Compare two JSON strings *)

     

       133
       133
       +
       let compare_json_strings expected actual =

     

       134
       134
       +
         (* Handle empty strings *)

     

       135
       135
       +
         let expected_trimmed = String.trim expected in

     

       136
       136
       +
         let actual_trimmed = String.trim actual in

     

       137
       137
       +
         if expected_trimmed = "" && actual_trimmed = "" then

     

       138
       138
       +
           true

     

       139
       139
       +
         else if expected_trimmed = "" || actual_trimmed = "" then

     

       140
       140
       +
           false

     

       141
       141
       +
         else

     

       142
       142
       +
           (* Parse as potentially multiple JSON values *)

     

       143
       143
       +
           let expected_values = parse_json_multi expected in

     

       144
       144
       +
           let actual_values = parse_json_multi actual in

     

       145
       145
       +
           List.length expected_values = List.length actual_values &&

     

       146
       146
       +
           List.for_all2 equal expected_values actual_values

+69

tests/test_suite_lib/json_format.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
       +
       (* Format Value.t as JSON matching yaml-test-suite expected format *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Yamlrw

     

       9
       9
       +
       

     

       10
       10
       +
       let escape_string s =

     

       11
       11
       +
         let buf = Buffer.create (String.length s * 2) in

     

       12
       12
       +
         Buffer.add_char buf '"';

     

       13
       13
       +
         String.iter (fun c ->

     

       14
       14
       +
           match c with

     

       15
       15
       +
           | '"' -> Buffer.add_string buf "\\\""

     

       16
       16
       +
           | '\\' -> Buffer.add_string buf "\\\\"

     

       17
       17
       +
           | '\n' -> Buffer.add_string buf "\\n"

     

       18
       18
       +
           | '\r' -> Buffer.add_string buf "\\r"

     

       19
       19
       +
           | '\t' -> Buffer.add_string buf "\\t"

     

       20
       20
       +
           | '\x08' -> Buffer.add_string buf "\\b"

     

       21
       21
       +
           | '\x0c' -> Buffer.add_string buf "\\f"

     

       22
       22
       +
           | c when Char.code c < 32 ->

     

       23
       23
       +
               Buffer.add_string buf (Printf.sprintf "\\u%04x" (Char.code c))

     

       24
       24
       +
           | c -> Buffer.add_char buf c

     

       25
       25
       +
         ) s;

     

       26
       26
       +
         Buffer.add_char buf '"';

     

       27
       27
       +
         Buffer.contents buf

     

       28
       28
       +
       

     

       29
       29
       +
       let rec format_value ?(indent=0) (v : Value.t) =

     

       30
       30
       +
         let spaces n = String.make n ' ' in

     

       31
       31
       +
         match v with

     

       32
       32
       +
         | `Null -> "null"

     

       33
       33
       +
         | `Bool true -> "true"

     

       34
       34
       +
         | `Bool false -> "false"

     

       35
       35
       +
         | `Float f ->

     

       36
       36
       +
             if Float.is_nan f then "null"  (* JSON doesn't support NaN *)

     

       37
       37
       +
             else if f = Float.infinity || f = Float.neg_infinity then "null"  (* JSON doesn't support Inf *)

     

       38
       38
       +
             else if Float.is_integer f && Float.abs f < 1e15 then

     

       39
       39
       +
               Printf.sprintf "%.0f" f

     

       40
       40
       +
             else

     

       41
       41
       +
               (* Try to match yaml-test-suite's number formatting *)

     

       42
       42
       +
               let s = Printf.sprintf "%g" f in

     

       43
       43
       +
               (* Ensure we have a decimal point for floats *)

     

       44
       44
       +
               if String.contains s '.' || String.contains s 'e' || String.contains s 'E' then s

     

       45
       45
       +
               else s ^ ".0"

     

       46
       46
       +
         | `String s -> escape_string s

     

       47
       47
       +
         | `A [] -> "[]"

     

       48
       48
       +
         | `A items ->

     

       49
       49
       +
             let inner_indent = indent + 2 in

     

       50
       50
       +
             let formatted_items = List.map (fun item ->

     

       51
       51
       +
               spaces inner_indent ^ format_value ~indent:inner_indent item

     

       52
       52
       +
             ) items in

     

       53
       53
       +
             "[\n" ^ String.concat ",\n" formatted_items ^ "\n" ^ spaces indent ^ "]"

     

       54
       54
       +
         | `O [] -> "{}"

     

       55
       55
       +
         | `O pairs ->

     

       56
       56
       +
             let inner_indent = indent + 2 in

     

       57
       57
       +
             let formatted_pairs = List.map (fun (k, v) ->

     

       58
       58
       +
               let key = escape_string k in

     

       59
       59
       +
               let value = format_value ~indent:inner_indent v in

     

       60
       60
       +
               spaces inner_indent ^ key ^ ": " ^ value

     

       61
       61
       +
             ) pairs in

     

       62
       62
       +
             "{\n" ^ String.concat ",\n" formatted_pairs ^ "\n" ^ spaces indent ^ "}"

     

       63
       63
       +
       

     

       64
       64
       +
       let to_json (v : Value.t) : string =

     

       65
       65
       +
         format_value v

     

       66
       66
       +
       

     

       67
       67
       +
       (* Format multiple documents (for multi-doc YAML) *)

     

       68
       68
       +
       let documents_to_json (docs : Value.t list) : string =

     

       69
       69
       +
         String.concat "\n" (List.map to_json docs)

+45

tests/test_suite_lib/test_suite_loader.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
       +
       (** Load yaml-test-suite test cases using standard OCaml I/O *)

     

       7
       7
       +
       

     

       8
       8
       +
       (** Synchronous file I/O implementation *)

     

       9
       9
       +
       module Sync_io : Test_suite_loader_generic.FILE_IO with type ctx = unit = struct

     

       10
       10
       +
         type ctx = unit

     

       11
       11
       +
       

     

       12
       12
       +
         let read_file () path =

     

       13
       13
       +
           try

     

       14
       14
       +
             let ic = open_in path in

     

       15
       15
       +
             let n = in_channel_length ic in

     

       16
       16
       +
             let s = really_input_string ic n in

     

       17
       17
       +
             close_in ic;

     

       18
       18
       +
             Some s

     

       19
       19
       +
           with _ -> None

     

       20
       20
       +
       

     

       21
       21
       +
         let file_exists () path =

     

       22
       22
       +
           Sys.file_exists path

     

       23
       23
       +
       

     

       24
       24
       +
         let is_directory () path =

     

       25
       25
       +
           Sys.file_exists path && Sys.is_directory path

     

       26
       26
       +
       

     

       27
       27
       +
         let read_dir () path =

     

       28
       28
       +
           Array.to_list (Sys.readdir path)

     

       29
       29
       +
       end

     

       30
       30
       +
       

     

       31
       31
       +
       (** Internal loader module *)

     

       32
       32
       +
       module Loader = Test_suite_loader_generic.Make(Sync_io)

     

       33
       33
       +
       

     

       34
       34
       +
       (** Re-export test_case type from loader *)

     

       35
       35
       +
       type test_case = Loader.test_case = {

     

       36
       36
       +
         id : string;

     

       37
       37
       +
         name : string;

     

       38
       38
       +
         yaml : string;

     

       39
       39
       +
         tree : string option;

     

       40
       40
       +
         json : string option;

     

       41
       41
       +
         fail : bool;

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       (** Load tests without needing to pass a context *)

     

       45
       45
       +
       let load_directory path : test_case list = Loader.load_directory () path

+67

tests/test_suite_lib/test_suite_loader_eio.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
       +
       (** Load yaml-test-suite test cases using Eio for file I/O *)

     

       7
       7
       +
       

     

       8
       8
       +
       module Generic = Test_suite_lib.Test_suite_loader_generic

     

       9
       9
       +
       

     

       10
       10
       +
       (** Eio file I/O implementation *)

     

       11
       11
       +
       module Eio_io : Generic.FILE_IO with type ctx = Eio.Fs.dir_ty Eio.Path.t = struct

     

       12
       12
       +
         type ctx = Eio.Fs.dir_ty Eio.Path.t

     

       13
       13
       +
       

     

       14
       14
       +
         let read_file fs path =

     

       15
       15
       +
           try

     

       16
       16
       +
             Some (Eio.Path.load Eio.Path.(fs / path))

     

       17
       17
       +
           with _ -> None

     

       18
       18
       +
       

     

       19
       19
       +
         let file_exists fs path =

     

       20
       20
       +
           match Eio.Path.kind ~follow:true Eio.Path.(fs / path) with

     

       21
       21
       +
           | `Regular_file -> true

     

       22
       22
       +
           | _ -> false

     

       23
       23
       +
           | exception _ -> false

     

       24
       24
       +
       

     

       25
       25
       +
         let is_directory fs path =

     

       26
       26
       +
           match Eio.Path.kind ~follow:true Eio.Path.(fs / path) with

     

       27
       27
       +
           | `Directory -> true

     

       28
       28
       +
           | _ -> false

     

       29
       29
       +
           | exception _ -> false

     

       30
       30
       +
       

     

       31
       31
       +
         let read_dir fs path =

     

       32
       32
       +
           Eio.Path.read_dir Eio.Path.(fs / path)

     

       33
       33
       +
       end

     

       34
       34
       +
       

     

       35
       35
       +
       (** Internal loader module *)

     

       36
       36
       +
       module Loader = Generic.Make(Eio_io)

     

       37
       37
       +
       

     

       38
       38
       +
       (** Re-export test_case type from loader *)

     

       39
       39
       +
       type test_case = Loader.test_case = {

     

       40
       40
       +
         id : string;

     

       41
       41
       +
         name : string;

     

       42
       42
       +
         yaml : string;

     

       43
       43
       +
         tree : string option;

     

       44
       44
       +
         json : string option;

     

       45
       45
       +
         fail : bool;

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

       48
       48
       +
       (** Load tests with Eio filesystem context *)

     

       49
       49
       +
       let load_directory ~fs path : test_case list = Loader.load_directory fs path

     

       50
       50
       +
       

     

       51
       51
       +
       (** Parallel loading of test directories - load all test IDs concurrently *)

     

       52
       52
       +
       let load_directory_parallel ~fs test_suite_path : test_case list =

     

       53
       53
       +
         if not (Eio_io.is_directory fs test_suite_path) then []

     

       54
       54
       +
         else

     

       55
       55
       +
           let entries = Eio_io.read_dir fs test_suite_path in

     

       56
       56
       +
           let test_ids = entries

     

       57
       57
       +
             |> List.filter (fun e ->

     

       58
       58
       +
                 Eio_io.is_directory fs (Filename.concat test_suite_path e) &&

     

       59
       59
       +
                 String.length e >= 4 &&

     

       60
       60
       +
                 e.[0] >= '0' && e.[0] <= 'Z')

     

       61
       61
       +
             |> List.sort String.compare

     

       62
       62
       +
           in

     

       63
       63
       +
           (* Load each test ID in parallel using fibers *)

     

       64
       64
       +
           Eio.Fiber.List.map (fun test_id ->

     

       65
       65
       +
             Loader.load_test_id fs test_suite_path test_id

     

       66
       66
       +
           ) test_ids

     

       67
       67
       +
           |> List.concat

+121

tests/test_suite_lib/test_suite_loader_generic.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
       +
       (** Generic test suite loader - parameterized by file I/O operations *)

     

       7
       7
       +
       

     

       8
       8
       +
       (** Test case representation *)

     

       9
       9
       +
       type test_case = {

     

       10
       10
       +
         id : string;

     

       11
       11
       +
         name : string;

     

       12
       12
       +
         yaml : string;

     

       13
       13
       +
         tree : string option;

     

       14
       14
       +
         json : string option;

     

       15
       15
       +
         fail : bool;

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       (** Module type for file I/O operations *)

     

       19
       19
       +
       module type FILE_IO = sig

     

       20
       20
       +
         (** Context type for file operations (unit for sync, ~fs for Eio) *)

     

       21
       21
       +
         type ctx

     

       22
       22
       +
       

     

       23
       23
       +
         (** Read a file, returning None if it doesn't exist or can't be read *)

     

       24
       24
       +
         val read_file : ctx -> string -> string option

     

       25
       25
       +
       

     

       26
       26
       +
         (** Check if a path exists and is a regular file *)

     

       27
       27
       +
         val file_exists : ctx -> string -> bool

     

       28
       28
       +
       

     

       29
       29
       +
         (** Check if a path exists and is a directory *)

     

       30
       30
       +
         val is_directory : ctx -> string -> bool

     

       31
       31
       +
       

     

       32
       32
       +
         (** List directory entries *)

     

       33
       33
       +
         val read_dir : ctx -> string -> string list

     

       34
       34
       +
       end

     

       35
       35
       +
       

     

       36
       36
       +
       (** Create a test loader from file I/O operations *)

     

       37
       37
       +
       module Make (IO : FILE_IO) = struct

     

       38
       38
       +
         type test_case = {

     

       39
       39
       +
           id : string;

     

       40
       40
       +
           name : string;

     

       41
       41
       +
           yaml : string;

     

       42
       42
       +
           tree : string option;

     

       43
       43
       +
           json : string option;

     

       44
       44
       +
           fail : bool;

     

       45
       45
       +
         }

     

       46
       46
       +
       

     

       47
       47
       +
         let read_file_required ctx path =

     

       48
       48
       +
           match IO.read_file ctx path with

     

       49
       49
       +
           | Some s -> s

     

       50
       50
       +
           | None -> ""

     

       51
       51
       +
       

     

       52
       52
       +
         (** Load a single test from a directory *)

     

       53
       53
       +
         let load_test_dir ctx base_id dir_path =

     

       54
       54
       +
           let name_file = Filename.concat dir_path "===" in

     

       55
       55
       +
           let yaml_file = Filename.concat dir_path "in.yaml" in

     

       56
       56
       +
           let tree_file = Filename.concat dir_path "test.event" in

     

       57
       57
       +
           let json_file = Filename.concat dir_path "in.json" in

     

       58
       58
       +
           let error_file = Filename.concat dir_path "error" in

     

       59
       59
       +
       

     

       60
       60
       +
           (* Must have in.yaml to be a valid test *)

     

       61
       61
       +
           if not (IO.file_exists ctx yaml_file) then None

     

       62
       62
       +
           else

     

       63
       63
       +
             let name = match IO.read_file ctx name_file with

     

       64
       64
       +
               | Some s -> String.trim s

     

       65
       65
       +
               | None -> base_id

     

       66
       66
       +
             in

     

       67
       67
       +
             let yaml = read_file_required ctx yaml_file in

     

       68
       68
       +
             let tree = IO.read_file ctx tree_file in

     

       69
       69
       +
             let json = IO.read_file ctx json_file in

     

       70
       70
       +
             let fail = IO.file_exists ctx error_file in

     

       71
       71
       +
             Some { id = base_id; name; yaml; tree; json; fail }

     

       72
       72
       +
       

     

       73
       73
       +
         (** Load tests from a test ID directory (may have subdirectories for variants) *)

     

       74
       74
       +
         let load_test_id ctx test_suite_path test_id =

     

       75
       75
       +
           let dir_path = Filename.concat test_suite_path test_id in

     

       76
       76
       +
           if not (IO.is_directory ctx dir_path) then []

     

       77
       77
       +
           else

     

       78
       78
       +
             let entries = IO.read_dir ctx dir_path in

     

       79
       79
       +
             (* Check if this directory has variant subdirectories (00, 01, etc.) *)

     

       80
       80
       +
             let has_variants = List.exists (fun e ->

     

       81
       81
       +
               let subdir = Filename.concat dir_path e in

     

       82
       82
       +
               IO.is_directory ctx subdir &&

     

       83
       83
       +
               String.length e >= 2 &&

     

       84
       84
       +
               e.[0] >= '0' && e.[0] <= '9'

     

       85
       85
       +
             ) entries in

     

       86
       86
       +
       

     

       87
       87
       +
             if has_variants then

     

       88
       88
       +
               (* Load each variant subdirectory *)

     

       89
       89
       +
               let variants = entries

     

       90
       90
       +
                 |> List.filter (fun e ->

     

       91
       91
       +
                     let subdir = Filename.concat dir_path e in

     

       92
       92
       +
                     IO.is_directory ctx subdir &&

     

       93
       93
       +
                     String.length e >= 2 &&

     

       94
       94
       +
                     e.[0] >= '0' && e.[0] <= '9')

     

       95
       95
       +
                 |> List.sort String.compare

     

       96
       96
       +
               in

     

       97
       97
       +
               List.filter_map (fun variant ->

     

       98
       98
       +
                 let variant_path = Filename.concat dir_path variant in

     

       99
       99
       +
                 let variant_id = Printf.sprintf "%s:%s" test_id variant in

     

       100
       100
       +
                 load_test_dir ctx variant_id variant_path

     

       101
       101
       +
               ) variants

     

       102
       102
       +
             else

     

       103
       103
       +
               (* Single test in this directory *)

     

       104
       104
       +
               match load_test_dir ctx test_id dir_path with

     

       105
       105
       +
               | Some t -> [t]

     

       106
       106
       +
               | None -> []

     

       107
       107
       +
       

     

       108
       108
       +
         (** Load all tests from a test suite directory *)

     

       109
       109
       +
         let load_directory ctx test_suite_path =

     

       110
       110
       +
           if not (IO.is_directory ctx test_suite_path) then []

     

       111
       111
       +
           else

     

       112
       112
       +
             let entries = IO.read_dir ctx test_suite_path in

     

       113
       113
       +
             let test_ids = entries

     

       114
       114
       +
               |> List.filter (fun e ->

     

       115
       115
       +
                   IO.is_directory ctx (Filename.concat test_suite_path e) &&

     

       116
       116
       +
                   String.length e >= 4 &&

     

       117
       117
       +
                   e.[0] >= '0' && e.[0] <= 'Z')

     

       118
       118
       +
               |> List.sort String.compare

     

       119
       119
       +
             in

     

       120
       120
       +
             List.concat_map (load_test_id ctx test_suite_path) test_ids

     

       121
       121
       +
       end

+74

tests/test_suite_lib/tree_format.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
       +
       (* Format parser events as tree notation compatible with yaml-test-suite *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Yamlrw

     

       9
       9
       +
       

     

       10
       10
       +
       let escape_string s =

     

       11
       11
       +
         let buf = Buffer.create (String.length s * 2) in

     

       12
       12
       +
         String.iter (fun c ->

     

       13
       13
       +
           match c with

     

       14
       14
       +
           | '\n' -> Buffer.add_string buf "\\n"

     

       15
       15
       +
           | '\t' -> Buffer.add_string buf "\\t"

     

       16
       16
       +
           | '\r' -> Buffer.add_string buf "\\r"

     

       17
       17
       +
           | '\\' -> Buffer.add_string buf "\\\\"

     

       18
       18
       +
           | '\x00' -> Buffer.add_string buf "\\0"

     

       19
       19
       +
           | '\x07' -> Buffer.add_string buf "\\a"

     

       20
       20
       +
           | '\x08' -> Buffer.add_string buf "\\b"

     

       21
       21
       +
           | '\x0b' -> Buffer.add_string buf "\\v"

     

       22
       22
       +
           | '\x0c' -> Buffer.add_string buf "\\f"

     

       23
       23
       +
           | '\x1b' -> Buffer.add_string buf "\\e"

     

       24
       24
       +
           | '\xa0' -> Buffer.add_string buf "\\_"

     

       25
       25
       +
           | c -> Buffer.add_char buf c

     

       26
       26
       +
         ) s;

     

       27
       27
       +
         Buffer.contents buf

     

       28
       28
       +
       

     

       29
       29
       +
       let style_char = function

     

       30
       30
       +
         | `Plain -> ':'

     

       31
       31
       +
         | `Single_quoted -> '\''

     

       32
       32
       +
         | `Double_quoted -> '"'

     

       33
       33
       +
         | `Literal -> '|'

     

       34
       34
       +
         | `Folded -> '>'

     

       35
       35
       +
         | `Any -> ':'

     

       36
       36
       +
       

     

       37
       37
       +
       let format_event { Event.event; span = _span } =

     

       38
       38
       +
         match event with

     

       39
       39
       +
         | Event.Stream_start _ -> "+STR"

     

       40
       40
       +
         | Event.Stream_end -> "-STR"

     

       41
       41
       +
         | Event.Document_start { implicit; _ } ->

     

       42
       42
       +
             if implicit then "+DOC"

     

       43
       43
       +
             else "+DOC ---"

     

       44
       44
       +
         | Event.Document_end { implicit } ->

     

       45
       45
       +
             if implicit then "-DOC"

     

       46
       46
       +
             else "-DOC ..."

     

       47
       47
       +
         | Event.Mapping_start { anchor; tag; style; _ } ->

     

       48
       48
       +
             let anchor_str = match anchor with Some a -> " &" ^ a | None -> "" in

     

       49
       49
       +
             let tag_str = match tag with Some t -> " <" ^ t ^ ">" | None -> "" in

     

       50
       50
       +
             let flow_str = match style with `Flow -> " {}" | _ -> "" in

     

       51
       51
       +
             Printf.sprintf "+MAP%s%s%s" flow_str anchor_str tag_str

     

       52
       52
       +
         | Event.Mapping_end -> "-MAP"

     

       53
       53
       +
         | Event.Sequence_start { anchor; tag; style; _ } ->

     

       54
       54
       +
             let anchor_str = match anchor with Some a -> " &" ^ a | None -> "" in

     

       55
       55
       +
             let tag_str = match tag with Some t -> " <" ^ t ^ ">" | None -> "" in

     

       56
       56
       +
             let flow_str = match style with `Flow -> " []" | _ -> "" in

     

       57
       57
       +
             Printf.sprintf "+SEQ%s%s%s" flow_str anchor_str tag_str

     

       58
       58
       +
         | Event.Sequence_end -> "-SEQ"

     

       59
       59
       +
         | Event.Scalar { anchor; tag; value; style; _ } ->

     

       60
       60
       +
             let anchor_str = match anchor with Some a -> " &" ^ a | None -> "" in

     

       61
       61
       +
             let tag_str = match tag with Some t -> " <" ^ t ^ ">" | None -> "" in

     

       62
       62
       +
             let style_c = style_char style in

     

       63
       63
       +
             Printf.sprintf "=VAL%s%s %c%s" anchor_str tag_str style_c (escape_string value)

     

       64
       64
       +
         | Event.Alias { anchor } ->

     

       65
       65
       +
             Printf.sprintf "=ALI *%s" anchor

     

       66
       66
       +
       

     

       67
       67
       +
       let of_spanned_events events =

     

       68
       68
       +
         let buf = Buffer.create 256 in

     

       69
       69
       +
         List.iter (fun (e : Event.spanned) ->

     

       70
       70
       +
           let line = format_event e in

     

       71
       71
       +
           Buffer.add_string buf line;

     

       72
       72
       +
           Buffer.add_char buf '\n'

     

       73
       73
       +
         ) events;

     

       74
       74
       +
         Buffer.contents buf

+358

tests/test_yamlrw.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
       +
       (** Tests for the Yamlrw library *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Yamlrw

     

       9
       9
       +
       

     

       10
       10
       +
       (** Test helpers *)

     

       11
       11
       +
       

     

       12
       12
       +
       let check_value msg expected actual =

     

       13
       13
       +
         Alcotest.(check bool) msg true (Value.equal expected actual)

     

       14
       14
       +
       

     

       15
       15
       +
       let _check_string msg expected actual =

     

       16
       16
       +
         Alcotest.(check string) msg expected actual

     

       17
       17
       +
       

     

       18
       18
       +
       (** Scanner tests *)

     

       19
       19
       +
       

     

       20
       20
       +
       let test_scanner_simple () =

     

       21
       21
       +
         let scanner = Scanner.of_string "hello: world" in

     

       22
       22
       +
         let tokens = Scanner.to_list scanner in

     

       23
       23
       +
         let token_types = List.map (fun (t : Token.spanned) -> t.token) tokens in

     

       24
       24
       +
         Alcotest.(check int) "token count" 8 (List.length token_types);

     

       25
       25
       +
         (* Stream_start, Block_mapping_start, Key, Scalar, Value, Scalar, Block_end, Stream_end *)

     

       26
       26
       +
         match token_types with

     

       27
       27
       +
         | Token.Stream_start _ :: Token.Block_mapping_start :: Token.Key ::

     

       28
       28
       +
           Token.Scalar { value = "hello"; _ } :: Token.Value ::

     

       29
       29
       +
           Token.Scalar { value = "world"; _ } :: Token.Block_end :: Token.Stream_end :: [] ->

     

       30
       30
       +
             ()

     

       31
       31
       +
         | _ ->

     

       32
       32
       +
             Alcotest.fail "unexpected token sequence"

     

       33
       33
       +
       

     

       34
       34
       +
       let test_scanner_sequence () =

     

       35
       35
       +
         let scanner = Scanner.of_string "- one\n- two\n- three" in

     

       36
       36
       +
         let tokens = Scanner.to_list scanner in

     

       37
       37
       +
         Alcotest.(check bool) "has tokens" true (List.length tokens > 0)

     

       38
       38
       +
       

     

       39
       39
       +
       let test_scanner_flow () =

     

       40
       40
       +
         let scanner = Scanner.of_string "[1, 2, 3]" in

     

       41
       41
       +
         let tokens = Scanner.to_list scanner in

     

       42
       42
       +
         let has_flow_start = List.exists (fun (t : Token.spanned) ->

     

       43
       43
       +
           match t.token with Token.Flow_sequence_start -> true | _ -> false

     

       44
       44
       +
         ) tokens in

     

       45
       45
       +
         Alcotest.(check bool) "has flow sequence start" true has_flow_start

     

       46
       46
       +
       

     

       47
       47
       +
       let scanner_tests = [

     

       48
       48
       +
         "simple mapping", `Quick, test_scanner_simple;

     

       49
       49
       +
         "sequence", `Quick, test_scanner_sequence;

     

       50
       50
       +
         "flow sequence", `Quick, test_scanner_flow;

     

       51
       51
       +
       ]

     

       52
       52
       +
       

     

       53
       53
       +
       (** Parser tests *)

     

       54
       54
       +
       

     

       55
       55
       +
       let test_parser_events () =

     

       56
       56
       +
         let parser = Parser.of_string "key: value" in

     

       57
       57
       +
         let events = Parser.to_list parser in

     

       58
       58
       +
         Alcotest.(check bool) "has events" true (List.length events > 0);

     

       59
       59
       +
         let has_stream_start = List.exists (fun (e : Event.spanned) ->

     

       60
       60
       +
           match e.event with Event.Stream_start _ -> true | _ -> false

     

       61
       61
       +
         ) events in

     

       62
       62
       +
         Alcotest.(check bool) "has stream start" true has_stream_start

     

       63
       63
       +
       

     

       64
       64
       +
       let test_parser_sequence_events () =

     

       65
       65
       +
         let parser = Parser.of_string "- a\n- b" in

     

       66
       66
       +
         let events = Parser.to_list parser in

     

       67
       67
       +
         let has_seq_start = List.exists (fun (e : Event.spanned) ->

     

       68
       68
       +
           match e.event with Event.Sequence_start _ -> true | _ -> false

     

       69
       69
       +
         ) events in

     

       70
       70
       +
         Alcotest.(check bool) "has sequence start" true has_seq_start

     

       71
       71
       +
       

     

       72
       72
       +
       let parser_tests = [

     

       73
       73
       +
         "parse events", `Quick, test_parser_events;

     

       74
       74
       +
         "sequence events", `Quick, test_parser_sequence_events;

     

       75
       75
       +
       ]

     

       76
       76
       +
       

     

       77
       77
       +
       (** Value parsing tests *)

     

       78
       78
       +
       

     

       79
       79
       +
       let test_parse_null () =

     

       80
       80
       +
         check_value "null" `Null (of_string "null");

     

       81
       81
       +
         check_value "~" `Null (of_string "~");

     

       82
       82
       +
         check_value "empty" `Null (of_string "")

     

       83
       83
       +
       

     

       84
       84
       +
       let test_parse_bool () =

     

       85
       85
       +
         check_value "true" (`Bool true) (of_string "true");

     

       86
       86
       +
         check_value "false" (`Bool false) (of_string "false");

     

       87
       87
       +
         check_value "yes" (`Bool true) (of_string "yes");

     

       88
       88
       +
         check_value "no" (`Bool false) (of_string "no")

     

       89
       89
       +
       

     

       90
       90
       +
       let test_parse_number () =

     

       91
       91
       +
         check_value "integer" (`Float 42.0) (of_string "42");

     

       92
       92
       +
         check_value "negative" (`Float (-17.0)) (of_string "-17");

     

       93
       93
       +
         check_value "float" (`Float 3.14) (of_string "3.14")

     

       94
       94
       +
       

     

       95
       95
       +
       let test_parse_string () =

     

       96
       96
       +
         check_value "plain" (`String "hello") (of_string "hello world" |> function `String s -> `String (String.sub s 0 5) | v -> v);

     

       97
       97
       +
         check_value "quoted" (`String "hello") (of_string {|"hello"|})

     

       98
       98
       +
       

     

       99
       99
       +
       let test_parse_sequence () =

     

       100
       100
       +
         let result = of_string "- one\n- two\n- three" in

     

       101
       101
       +
         match result with

     

       102
       102
       +
         | `A [_; _; _] -> ()

     

       103
       103
       +
         | _ -> Alcotest.fail "expected sequence with 3 elements"

     

       104
       104
       +
       

     

       105
       105
       +
       let test_parse_mapping () =

     

       106
       106
       +
         let result = of_string "name: Alice\nage: 30" in

     

       107
       107
       +
         match result with

     

       108
       108
       +
         | `O pairs when List.length pairs = 2 -> ()

     

       109
       109
       +
         | _ -> Alcotest.fail "expected mapping with 2 pairs"

     

       110
       110
       +
       

     

       111
       111
       +
       let test_parse_nested () =

     

       112
       112
       +
         let yaml = {|

     

       113
       113
       +
       person:

     

       114
       114
       +
         name: Bob

     

       115
       115
       +
         hobbies:

     

       116
       116
       +
           - reading

     

       117
       117
       +
           - coding

     

       118
       118
       +
       |} in

     

       119
       119
       +
         let result = of_string yaml in

     

       120
       120
       +
         match result with

     

       121
       121
       +
         | `O [("person", `O _)] -> ()

     

       122
       122
       +
         | _ -> Alcotest.fail "expected nested structure"

     

       123
       123
       +
       

     

       124
       124
       +
       let test_parse_flow_sequence () =

     

       125
       125
       +
         let result = of_string "[1, 2, 3]" in

     

       126
       126
       +
         match result with

     

       127
       127
       +
         | `A [`Float 1.0; `Float 2.0; `Float 3.0] -> ()

     

       128
       128
       +
         | _ -> Alcotest.fail "expected flow sequence [1, 2, 3]"

     

       129
       129
       +
       

     

       130
       130
       +
       let test_parse_flow_mapping () =

     

       131
       131
       +
         let result = of_string "{a: 1, b: 2}" in

     

       132
       132
       +
         match result with

     

       133
       133
       +
         | `O [("a", `Float 1.0); ("b", `Float 2.0)] -> ()

     

       134
       134
       +
         | _ -> Alcotest.fail "expected flow mapping {a: 1, b: 2}"

     

       135
       135
       +
       

     

       136
       136
       +
       let test_parse_flow_mapping_trailing_comma () =

     

       137
       137
       +
         let result = of_string "{ a: 1, }" in

     

       138
       138
       +
         match result with

     

       139
       139
       +
         | `O [("a", `Float 1.0)] -> ()

     

       140
       140
       +
         | `O pairs ->

     

       141
       141
       +
             Alcotest.failf "expected 1 pair but got %d pairs (trailing comma should not create empty entry)"

     

       142
       142
       +
               (List.length pairs)

     

       143
       143
       +
         | _ -> Alcotest.fail "expected flow mapping with 1 pair"

     

       144
       144
       +
       

     

       145
       145
       +
       let value_tests = [

     

       146
       146
       +
         "parse null", `Quick, test_parse_null;

     

       147
       147
       +
         "parse bool", `Quick, test_parse_bool;

     

       148
       148
       +
         "parse number", `Quick, test_parse_number;

     

       149
       149
       +
         "parse string", `Quick, test_parse_string;

     

       150
       150
       +
         "parse sequence", `Quick, test_parse_sequence;

     

       151
       151
       +
         "parse mapping", `Quick, test_parse_mapping;

     

       152
       152
       +
         "parse nested", `Quick, test_parse_nested;

     

       153
       153
       +
         "parse flow sequence", `Quick, test_parse_flow_sequence;

     

       154
       154
       +
         "parse flow mapping", `Quick, test_parse_flow_mapping;

     

       155
       155
       +
         "flow mapping trailing comma", `Quick, test_parse_flow_mapping_trailing_comma;

     

       156
       156
       +
       ]

     

       157
       157
       +
       

     

       158
       158
       +
       (** Emitter tests *)

     

       159
       159
       +
       

     

       160
       160
       +
       let test_emit_null () =

     

       161
       161
       +
         let result = to_string `Null in

     

       162
       162
       +
         Alcotest.(check bool) "contains null" true (String.length result > 0)

     

       163
       163
       +
       

     

       164
       164
       +
       let starts_with prefix s =

     

       165
       165
       +
         String.length s >= String.length prefix &&

     

       166
       166
       +
         String.sub s 0 (String.length prefix) = prefix

     

       167
       167
       +
       

     

       168
       168
       +
       let test_emit_mapping () =

     

       169
       169
       +
         let value = `O [("name", `String "Alice"); ("age", `Float 30.0)] in

     

       170
       170
       +
         let result = to_string value in

     

       171
       171
       +
         let trimmed = String.trim result in

     

       172
       172
       +
         Alcotest.(check bool) "contains name" true (starts_with "name" trimmed || starts_with "\"name\"" trimmed)

     

       173
       173
       +
       

     

       174
       174
       +
       let test_roundtrip_simple () =

     

       175
       175
       +
         let yaml = "name: Alice" in

     

       176
       176
       +
         let value = of_string yaml in

     

       177
       177
       +
         let _ = to_string value in

     

       178
       178
       +
         (* Just check it doesn't crash *)

     

       179
       179
       +
         ()

     

       180
       180
       +
       

     

       181
       181
       +
       let test_roundtrip_sequence () =

     

       182
       182
       +
         let yaml = "- one\n- two\n- three" in

     

       183
       183
       +
         let value = of_string yaml in

     

       184
       184
       +
         match value with

     

       185
       185
       +
         | `A items when List.length items = 3 ->

     

       186
       186
       +
             let _ = to_string value in

     

       187
       187
       +
             ()

     

       188
       188
       +
         | _ -> Alcotest.fail "roundtrip failed"

     

       189
       189
       +
       

     

       190
       190
       +
       let emitter_tests = [

     

       191
       191
       +
         "emit null", `Quick, test_emit_null;

     

       192
       192
       +
         "emit mapping", `Quick, test_emit_mapping;

     

       193
       193
       +
         "roundtrip simple", `Quick, test_roundtrip_simple;

     

       194
       194
       +
         "roundtrip sequence", `Quick, test_roundtrip_sequence;

     

       195
       195
       +
       ]

     

       196
       196
       +
       

     

       197
       197
       +
       (** YAML-specific tests *)

     

       198
       198
       +
       

     

       199
       199
       +
       let test_yaml_anchor () =

     

       200
       200
       +
         let yaml = "&anchor hello" in

     

       201
       201
       +
         let result = yaml_of_string yaml in

     

       202
       202
       +
         match result with

     

       203
       203
       +
         | `Scalar s when Scalar.anchor s = Some "anchor" -> ()

     

       204
       204
       +
         | _ -> Alcotest.fail "expected scalar with anchor"

     

       205
       205
       +
       

     

       206
       206
       +
       let test_yaml_alias () =

     

       207
       207
       +
         let yaml = {|

     

       208
       208
       +
       defaults: &defaults

     

       209
       209
       +
         timeout: 30

     

       210
       210
       +
       production:

     

       211
       211
       +
         <<: *defaults

     

       212
       212
       +
         port: 8080

     

       213
       213
       +
       |} in

     

       214
       214
       +
         (* Just check it parses without error *)

     

       215
       215
       +
         let _ = yaml_of_string yaml in

     

       216
       216
       +
         ()

     

       217
       217
       +
       

     

       218
       218
       +
       let yaml_tests = [

     

       219
       219
       +
         "yaml anchor", `Quick, test_yaml_anchor;

     

       220
       220
       +
         "yaml alias", `Quick, test_yaml_alias;

     

       221
       221
       +
       ]

     

       222
       222
       +
       

     

       223
       223
       +
       (** Multiline scalar tests *)

     

       224
       224
       +
       

     

       225
       225
       +
       let test_literal_block () =

     

       226
       226
       +
         let yaml = {|description: |

     

       227
       227
       +
         This is a

     

       228
       228
       +
         multi-line

     

       229
       229
       +
         description

     

       230
       230
       +
       |} in

     

       231
       231
       +
         let result = of_string yaml in

     

       232
       232
       +
         match result with

     

       233
       233
       +
         | `O [("description", `String _)] -> ()

     

       234
       234
       +
         | _ -> Alcotest.fail "expected mapping with literal block"

     

       235
       235
       +
       

     

       236
       236
       +
       let test_folded_block () =

     

       237
       237
       +
         let yaml = {|description: >

     

       238
       238
       +
         This is a

     

       239
       239
       +
         folded

     

       240
       240
       +
         description

     

       241
       241
       +
       |} in

     

       242
       242
       +
         let result = of_string yaml in

     

       243
       243
       +
         match result with

     

       244
       244
       +
         | `O [("description", `String _)] -> ()

     

       245
       245
       +
         | _ -> Alcotest.fail "expected mapping with folded block"

     

       246
       246
       +
       

     

       247
       247
       +
       let multiline_tests = [

     

       248
       248
       +
         "literal block", `Quick, test_literal_block;

     

       249
       249
       +
         "folded block", `Quick, test_folded_block;

     

       250
       250
       +
       ]

     

       251
       251
       +
       

     

       252
       252
       +
       (** Error handling tests *)

     

       253
       253
       +
       

     

       254
       254
       +
       let test_error_position () =

     

       255
       255
       +
         try

     

       256
       256
       +
           let _ = of_string "key: [unclosed" in

     

       257
       257
       +
           Alcotest.fail "expected error"

     

       258
       258
       +
         with

     

       259
       259
       +
         | Yamlrw_error e ->

     

       260
       260
       +
             Alcotest.(check bool) "has span" true (e.span <> None)

     

       261
       261
       +
       

     

       262
       262
       +
       let error_tests = [

     

       263
       263
       +
         "error position", `Quick, test_error_position;

     

       264
       264
       +
       ]

     

       265
       265
       +
       

     

       266
       266
       +
       (** Alias expansion limit tests (billion laughs protection) *)

     

       267
       267
       +
       

     

       268
       268
       +
       let test_node_limit () =

     

       269
       269
       +
         (* Small bomb that would expand to 9^4 = 6561 nodes *)

     

       270
       270
       +
         let yaml = {|

     

       271
       271
       +
       a: &a [1,2,3,4,5,6,7,8,9]

     

       272
       272
       +
       b: &b [*a,*a,*a,*a,*a,*a,*a,*a,*a]

     

       273
       273
       +
       c: &c [*b,*b,*b,*b,*b,*b,*b,*b,*b]

     

       274
       274
       +
       d: &d [*c,*c,*c,*c,*c,*c,*c,*c,*c]

     

       275
       275
       +
       |} in

     

       276
       276
       +
         (* Should fail with a small node limit *)

     

       277
       277
       +
         try

     

       278
       278
       +
           let _ = of_string ~max_nodes:100 yaml in

     

       279
       279
       +
           Alcotest.fail "expected node limit error"

     

       280
       280
       +
         with

     

       281
       281
       +
         | Yamlrw_error e ->

     

       282
       282
       +
             (match e.Error.kind with

     

       283
       283
       +
              | Error.Alias_expansion_node_limit _ -> ()

     

       284
       284
       +
              | _ -> Alcotest.fail "expected Alias_expansion_node_limit error")

     

       285
       285
       +
       

     

       286
       286
       +
       let test_depth_limit () =

     

       287
       287
       +
         (* Create deeply nested alias chain:

     

       288
       288
       +
            *e -> [*d,*d] -> [*c,*c] -> [*b,*b] -> [*a,*a] -> [x,y,z]

     

       289
       289
       +
            Each alias resolution increases depth by 1 *)

     

       290
       290
       +
         let yaml = {|

     

       291
       291
       +
       a: &a [x, y, z]

     

       292
       292
       +
       b: &b [*a, *a]

     

       293
       293
       +
       c: &c [*b, *b]

     

       294
       294
       +
       d: &d [*c, *c]

     

       295
       295
       +
       e: &e [*d, *d]

     

       296
       296
       +
       result: *e

     

       297
       297
       +
       |} in

     

       298
       298
       +
         (* Should fail with a small depth limit (depth 3 means max 3 alias hops) *)

     

       299
       299
       +
         try

     

       300
       300
       +
           let _ = of_string ~max_depth:3 yaml in

     

       301
       301
       +
           Alcotest.fail "expected depth limit error"

     

       302
       302
       +
         with

     

       303
       303
       +
         | Yamlrw_error e ->

     

       304
       304
       +
             (match e.Error.kind with

     

       305
       305
       +
              | Error.Alias_expansion_depth_limit _ -> ()

     

       306
       306
       +
              | _ -> Alcotest.fail ("expected Alias_expansion_depth_limit error, got: " ^ Error.kind_to_string e.Error.kind))

     

       307
       307
       +
       

     

       308
       308
       +
       let test_normal_aliases_work () =

     

       309
       309
       +
         (* Normal alias usage should work fine *)

     

       310
       310
       +
         let yaml = {|

     

       311
       311
       +
       defaults: &defaults

     

       312
       312
       +
         timeout: 30

     

       313
       313
       +
         retries: 3

     

       314
       314
       +
       production:

     

       315
       315
       +
         <<: *defaults

     

       316
       316
       +
         port: 8080

     

       317
       317
       +
       |} in

     

       318
       318
       +
         let result = of_string yaml in

     

       319
       319
       +
         match result with

     

       320
       320
       +
         | `O _ -> ()

     

       321
       321
       +
         | _ -> Alcotest.fail "expected mapping"

     

       322
       322
       +
       

     

       323
       323
       +
       let test_resolve_aliases_false () =

     

       324
       324
       +
         (* With resolve_aliases=false, aliases should remain unresolved *)

     

       325
       325
       +
         let yaml = {|

     

       326
       326
       +
       a: &anchor value

     

       327
       327
       +
       b: *anchor

     

       328
       328
       +
       |} in

     

       329
       329
       +
         let result = yaml_of_string ~resolve_aliases:false yaml in

     

       330
       330
       +
         (* Check that alias is preserved *)

     

       331
       331
       +
         match result with

     

       332
       332
       +
         | `O map ->

     

       333
       333
       +
             let pairs = Mapping.members map in

     

       334
       334
       +
             (match List.assoc_opt (`Scalar (Scalar.make "b")) pairs with

     

       335
       335
       +
              | Some (`Alias "anchor") -> ()

     

       336
       336
       +
              | _ -> Alcotest.fail "expected alias to be preserved")

     

       337
       337
       +
         | _ -> Alcotest.fail "expected mapping"

     

       338
       338
       +
       

     

       339
       339
       +
       let alias_limit_tests = [

     

       340
       340
       +
         "node limit", `Quick, test_node_limit;

     

       341
       341
       +
         "depth limit", `Quick, test_depth_limit;

     

       342
       342
       +
         "normal aliases work", `Quick, test_normal_aliases_work;

     

       343
       343
       +
         "resolve_aliases false", `Quick, test_resolve_aliases_false;

     

       344
       344
       +
       ]

     

       345
       345
       +
       

     

       346
       346
       +
       (** Run all tests *)

     

       347
       347
       +
       

     

       348
       348
       +
       let () =

     

       349
       349
       +
         Alcotest.run "yamlrw" [

     

       350
       350
       +
           "scanner", scanner_tests;

     

       351
       351
       +
           "parser", parser_tests;

     

       352
       352
       +
           "value", value_tests;

     

       353
       353
       +
           "emitter", emitter_tests;

     

       354
       354
       +
           "yaml", yaml_tests;

     

       355
       355
       +
           "multiline", multiline_tests;

     

       356
       356
       +
           "errors", error_tests;

     

       357
       357
       +
           "alias_limits", alias_limit_tests;

     

       358
       358
       +
         ]

+33

yamlrw-eio.opam

···

       1
       1
       +
       # This file is generated by dune, edit dune-project instead

     

       2
       2
       +
       opam-version: "2.0"

     

       3
       3
       +
       synopsis: "Eio support for Yamlrw"

     

       4
       4
       +
       description:

     

       5
       5
       +
         "Eio-based streaming I/O for Yamlrw. Provides efficient async YAML parsing and emission using the Eio effects-based concurrency library. Requires OCaml 5.0 or later."

     

       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-yamlrw"

     

       10
       10
       +
       bug-reports: "https://tangled.org/@anil.recoil.org/ocaml-yamlrw/issues"

     

       11
       11
       +
       depends: [

     

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

     

       13
       13
       +
         "ocaml" {>= "5.0.0"}

     

       14
       14
       +
         "yamlrw"

     

       15
       15
       +
         "bytesrw-eio"

     

       16
       16
       +
         "eio" {>= "1.1"}

     

       17
       17
       +
         "odoc" {with-doc}

     

       18
       18
       +
       ]

     

       19
       19
       +
       build: [

     

       20
       20
       +
         ["dune" "subst"] {dev}

     

       21
       21
       +
         [

     

       22
       22
       +
           "dune"

     

       23
       23
       +
           "build"

     

       24
       24
       +
           "-p"

     

       25
       25
       +
           name

     

       26
       26
       +
           "-j"

     

       27
       27
       +
           jobs

     

       28
       28
       +
           "@install"

     

       29
       29
       +
           "@runtest" {with-test}

     

       30
       30
       +
           "@doc" {with-doc}

     

       31
       31
       +
         ]

     

       32
       32
       +
       ]

     

       33
       33
       +
       x-maintenance-intent: ["(latest)"]

+32

yamlrw-unix.opam

···

       1
       1
       +
       # This file is generated by dune, edit dune-project instead

     

       2
       2
       +
       opam-version: "2.0"

     

       3
       3
       +
       synopsis: "Unix I/O for Yamlrw"

     

       4
       4
       +
       description:

     

       5
       5
       +
         "Unix file and channel operations for Yamlrw. Provides convenient functions for reading and writing YAML files using Unix I/O."

     

       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-yamlrw"

     

       10
       10
       +
       bug-reports: "https://tangled.org/@anil.recoil.org/ocaml-yamlrw/issues"

     

       11
       11
       +
       depends: [

     

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

     

       13
       13
       +
         "ocaml" {>= "4.14.0"}

     

       14
       14
       +
         "yamlrw"

     

       15
       15
       +
         "bytesrw"

     

       16
       16
       +
         "odoc" {with-doc}

     

       17
       17
       +
       ]

     

       18
       18
       +
       build: [

     

       19
       19
       +
         ["dune" "subst"] {dev}

     

       20
       20
       +
         [

     

       21
       21
       +
           "dune"

     

       22
       22
       +
           "build"

     

       23
       23
       +
           "-p"

     

       24
       24
       +
           name

     

       25
       25
       +
           "-j"

     

       26
       26
       +
           jobs

     

       27
       27
       +
           "@install"

     

       28
       28
       +
           "@runtest" {with-test}

     

       29
       29
       +
           "@doc" {with-doc}

     

       30
       30
       +
         ]

     

       31
       31
       +
       ]

     

       32
       32
       +
       x-maintenance-intent: ["(latest)"]

+33

yamlrw.opam

···

       1
       1
       +
       # This file is generated by dune, edit dune-project instead

     

       2
       2
       +
       opam-version: "2.0"

     

       3
       3
       +
       synopsis: "Pure OCaml YAML 1.2 parser and emitter"

     

       4
       4
       +
       description:

     

       5
       5
       +
         "Yamlrw is a pure OCaml implementation of YAML 1.2 parsing and emission. It provides both a high-level JSON-compatible interface for simple data interchange and a lower-level streaming API for fine-grained control over parsing and emission. The library works on all OCaml platforms without C dependencies."

     

       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-yamlrw"

     

       10
       10
       +
       bug-reports: "https://tangled.org/@anil.recoil.org/ocaml-yamlrw/issues"

     

       11
       11
       +
       depends: [

     

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

     

       13
       13
       +
         "ocaml" {>= "4.14.0"}

     

       14
       14
       +
         "bytesrw"

     

       15
       15
       +
         "cmdliner"

     

       16
       16
       +
         "odoc" {with-doc}

     

       17
       17
       +
         "alcotest" {with-test}

     

       18
       18
       +
       ]

     

       19
       19
       +
       build: [

     

       20
       20
       +
         ["dune" "subst"] {dev}

     

       21
       21
       +
         [

     

       22
       22
       +
           "dune"

     

       23
       23
       +
           "build"

     

       24
       24
       +
           "-p"

     

       25
       25
       +
           name

     

       26
       26
       +
           "-j"

     

       27
       27
       +
           jobs

     

       28
       28
       +
           "@install"

     

       29
       29
       +
           "@runtest" {with-test}

     

       30
       30
       +
           "@doc" {with-doc}

     

       31
       31
       +
         ]

     

       32
       32
       +
       ]

     

       33
       33
       +
       x-maintenance-intent: ["(latest)"]