···

       
0
       
 
       

     

···

       
1
       
+
       
version=0.27.0

     

···

       
26
       
 
       
    - bzip2

     

       
27
       
 
       
    - gcc

     

       
28
       
 
       
    - ocaml

     

       
0
       
 
       

     

       
29
       
 
       


     

       
30
       
 
       
steps:

     

       
31
       
 
       
  - name: opam

     

···

       
26
       
 
       
    - bzip2

     

       
27
       
 
       
    - gcc

     

       
28
       
 
       
    - ocaml

     

       
29
       
+
       
    - pkg-config

     

       
30
       
 
       


     

       
31
       
 
       
steps:

     

       
32
       
 
       
  - name: opam

     

···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

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

     

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

     

       
3
       
+
       


     

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

     

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

     

       
6
       
+
       


     

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

     

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

     

       
9
       
+
       


     

       
10
       
+
       
- Initial public release (@avsm)

     

       
11
       
+
       


     

···

       
133
       
 
       
- **feed_example.ml** - Creating and serializing feeds (blog and podcast)

     

       
134
       
 
       
- **feed_parser.ml** - Parsing and analyzing feeds from files

     

       
135
       
 
       
- **feed_validator.ml** - Validating feeds and demonstrating various feed types

     

       
0
       
 
       

     

       
136
       
 
       


     

       
137
       
 
       
Run examples:

     

       
138
       
 
       


     

       
139
       
 
       
```bash

     

       
140
       
-
       
opam exec -- dune exec -- ./example/feed_parser.exe

     

       
141
       
 
       
opam exec -- dune exec -- ./example/feed_example.exe

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
142
       
 
       
```

     

       
143
       
 
       


     

       
144
       
 
       
## API Documentation

     

···

       
133
       
 
       
- **feed_example.ml** - Creating and serializing feeds (blog and podcast)

     

       
134
       
 
       
- **feed_parser.ml** - Parsing and analyzing feeds from files

     

       
135
       
 
       
- **feed_validator.ml** - Validating feeds and demonstrating various feed types

     

       
136
       
+
       
- **feed_echo.ml** - Round-trip parsing: reads a feed from stdin and outputs to stdout

     

       
137
       
 
       


     

       
138
       
 
       
Run examples:

     

       
139
       
 
       


     

       
140
       
 
       
```bash

     

       
141
       
+
       
# Create and display sample feeds

     

       
142
       
 
       
opam exec -- dune exec -- ./example/feed_example.exe

     

       
143
       
+
       


     

       
144
       
+
       
# Parse and analyze a feed file

     

       
145
       
+
       
opam exec -- dune exec -- ./example/feed_parser.exe path/to/feed.json

     

       
146
       
+
       


     

       
147
       
+
       
# Validate feeds

     

       
148
       
+
       
opam exec -- dune exec -- ./example/feed_validator.exe

     

       
149
       
+
       


     

       
150
       
+
       
# Test round-trip parsing

     

       
151
       
+
       
cat feed.json | opam exec -- dune exec -- ./example/feed_echo.exe

     

       
152
       
 
       
```

     

       
153
       
 
       


     

       
154
       
 
       
## API Documentation

     

···

       
21
       
 
       
   and serialization using Jsonm and Ptime.")

     

       
22
       
 
       
 (depends

     

       
23
       
 
       
  (ocaml (>= 5.2.0))

     

       
24
       
-
       
  (jsonm (>= 1.0.0))

     

       
25
       
 
       
  (ptime (>= 1.2.0))

     

       
26
       
-
       
  (fmt (>= 0.11.0))

     

       
27
       
 
       
  (odoc :with-doc)

     

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

     

···

       
21
       
 
       
   and serialization using Jsonm and Ptime.")

     

       
22
       
 
       
 (depends

     

       
23
       
 
       
  (ocaml (>= 5.2.0))

     

       
24
       
+
       
  (jsont (>= 0.2.0))

     

       
25
       
 
       
  (ptime (>= 1.2.0))

     

       
26
       
+
       
  bytesrw

     

       
27
       
 
       
  (odoc :with-doc)

     

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

     

···

       
12
       
 
       
 (name feed_validator)

     

       
13
       
 
       
 (modules feed_validator)

     

       
14
       
 
       
 (libraries jsonfeed))

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
12
       
 
       
 (name feed_validator)

     

       
13
       
 
       
 (modules feed_validator)

     

       
14
       
 
       
 (libraries jsonfeed))

     

       
15
       
+
       


     

       
16
       
+
       
(executable

     

       
17
       
+
       
 (name feed_echo)

     

       
18
       
+
       
 (modules feed_echo)

     

       
19
       
+
       
 (libraries jsonfeed))

     

···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
(** Example: JSON Feed Echo

     

       
2
       
+
       


     

       
3
       
+
       
    Reads a JSON Feed from stdin, parses it, and outputs it to stdout. Useful

     

       
4
       
+
       
    for testing round-trip parsing and identifying any changes during

     

       
5
       
+
       
    serialization/deserialization.

     

       
6
       
+
       


     

       
7
       
+
       
    Usage: feed_echo < feed.json cat feed.json | feed_echo > output.json diff

     

       
8
       
+
       
    <(cat feed.json | feed_echo) feed.json

     

       
9
       
+
       


     

       
10
       
+
       
    Exit codes: 0 - Success 1 - Parsing or encoding failed *)

     

       
11
       
+
       


     

       
12
       
+
       
let echo_feed () =

     

       
13
       
+
       
  (* Create a bytesrw reader from stdin *)

     

       
14
       
+
       
  let stdin = Bytesrw.Bytes.Reader.of_in_channel In_channel.stdin in

     

       
15
       
+
       


     

       
16
       
+
       
  (* Parse the JSON feed *)

     

       
17
       
+
       
  match Jsonfeed.decode ~locs:true stdin with

     

       
18
       
+
       
  | Error err ->

     

       
19
       
+
       
      Format.eprintf "Parsing failed:\n  %s\n%!" (Jsont.Error.to_string err);

     

       
20
       
+
       
      exit 1

     

       
21
       
+
       
  | Ok feed -> (

     

       
22
       
+
       
      (* Encode the feed back to stdout *)

     

       
23
       
+
       
      match Jsonfeed.to_string ~minify:false feed with

     

       
24
       
+
       
      | Error err ->

     

       
25
       
+
       
          Format.eprintf "Encoding failed:\n  %s\n%!"

     

       
26
       
+
       
            (Jsont.Error.to_string err);

     

       
27
       
+
       
          exit 1

     

       
28
       
+
       
      | Ok json ->

     

       
29
       
+
       
          print_string json;

     

       
30
       
+
       
          print_newline ();

     

       
31
       
+
       
          exit 0)

     

       
32
       
+
       


     

       
33
       
+
       
let () = echo_feed ()

     

···

       
13
       
 
       
  match Jsonfeed.to_string feed with

     

       
14
       
 
       
  | Ok s ->

     

       
15
       
 
       
      Out_channel.with_open_gen

     

       
16
       
-
       
        [Open_wronly; Open_creat; Open_trunc; Open_text]

     

       
17
       
-
       
        0o644

     

       
18
       
-
       
        filename

     

       
19
       
 
       
        (fun oc -> Out_channel.output_string oc s)

     

       
20
       
 
       
  | Error e ->

     

       
21
       
 
       
      Printf.eprintf "Error encoding feed: %s\n" (Jsont.Error.to_string e);

     
···

       
23
       
 
       


     

       
24
       
 
       
let create_blog_feed () =

     

       
25
       
 
       
  (* Create some authors *)

     

       
26
       
-
       
  let jane = Author.create

     

       
27
       
-
       
    ~name:"Jane Doe"

     

       
28
       
-
       
    ~url:"https://example.com/authors/jane"

     

       
29
       
-
       
    ~avatar:"https://example.com/avatars/jane.png"

     

       
30
       
-
       
    () in

     

       
31
       
 
       


     

       
32
       
-
       
  let john = Author.create

     

       
33
       
-
       
    ~name:"John Smith"

     

       
34
       
-
       
    ~url:"https://example.com/authors/john"

     

       
35
       
-
       
    () in

     

       
36
       
 
       


     

       
37
       
 
       
  (* Create items with different content types *)

     

       
38
       
-
       
  let item1 = Item.create

     

       
39
       
-
       
    ~id:"https://example.com/posts/1"

     

       
40
       
-
       
    ~url:"https://example.com/posts/1"

     

       
41
       
-
       
    ~title:"Introduction to OCaml"

     

       
42
       
-
       
    ~content:(`Both (

     

       
43
       
-
       
      "<p>OCaml is a powerful functional programming language.</p>",

     

       
44
       
-
       
      "OCaml is a powerful functional programming language."

     

       
45
       
-
       
    ))

     

       
46
       
-
       
    ~date_published:(Jsonfeed.Rfc3339.parse "2024-11-01T10:00:00Z" |> Option.get)

     

       
47
       
-
       
    ~date_modified:(Jsonfeed.Rfc3339.parse "2024-11-01T15:30:00Z" |> Option.get)

     

       
48
       
-
       
    ~authors:[jane]

     

       
49
       
-
       
    ~tags:["ocaml"; "programming"; "functional"]

     

       
50
       
-
       
    ~summary:"A beginner's guide to OCaml programming"

     

       
51
       
-
       
    () in

     

       
0
       
 
       

     

       
52
       
 
       


     

       
53
       
-
       
  let item2 = Item.create

     

       
54
       
-
       
    ~id:"https://example.com/posts/2"

     

       
55
       
-
       
    ~url:"https://example.com/posts/2"

     

       
56
       
-
       
    ~title:"JSON Feed for Syndication"

     

       
57
       
-
       
    ~content:(`Html "<p>JSON Feed is a modern alternative to RSS and Atom.</p>")

     

       
58
       
-
       
    ~date_published:(Jsonfeed.Rfc3339.parse "2024-11-02T09:00:00Z" |> Option.get)

     

       
59
       
-
       
    ~authors:[jane; john]

     

       
60
       
-
       
    ~tags:["json"; "syndication"; "web"]

     

       
61
       
-
       
    ~image:"https://example.com/images/jsonfeed.png"

     

       
62
       
-
       
    () in

     

       
0
       
 
       

     

       
63
       
 
       


     

       
64
       
 
       
  (* Microblog-style item (text only, no title) *)

     

       
65
       
-
       
  let item3 = Item.create

     

       
66
       
-
       
    ~id:"https://example.com/micro/42"

     

       
67
       
-
       
    ~content:(`Text "Just shipped a new feature! 🚀")

     

       
68
       
-
       
    ~date_published:(Jsonfeed.Rfc3339.parse "2024-11-03T08:15:00Z" |> Option.get)

     

       
69
       
-
       
    ~tags:["microblog"]

     

       
70
       
-
       
    () in

     

       
0
       
 
       

     

       
71
       
 
       


     

       
72
       
 
       
  (* Create the complete feed *)

     

       
73
       
-
       
  let feed = Jsonfeed.create

     

       
74
       
-
       
    ~title:"Example Blog"

     

       
75
       
-
       
    ~home_page_url:"https://example.com"

     

       
76
       
-
       
    ~feed_url:"https://example.com/feed.json"

     

       
77
       
-
       
    ~description:"A blog about programming, web development, and technology"

     

       
78
       
-
       
    ~icon:"https://example.com/icon-512.png"

     

       
79
       
-
       
    ~favicon:"https://example.com/favicon-64.png"

     

       
80
       
-
       
    ~authors:[jane; john]

     

       
81
       
-
       
    ~language:"en-US"

     

       
82
       
-
       
    ~items:[item1; item2; item3]

     

       
83
       
-
       
    () in

     

       
84
       
 
       


     

       
85
       
 
       
  feed

     

       
86
       
 
       


     

       
87
       
 
       
let create_podcast_feed () =

     

       
88
       
 
       
  (* Create podcast author *)

     

       
89
       
-
       
  let host = Author.create

     

       
90
       
-
       
    ~name:"Podcast Host"

     

       
91
       
-
       
    ~url:"https://podcast.example.com/host"

     

       
92
       
-
       
    ~avatar:"https://podcast.example.com/host-avatar.jpg"

     

       
93
       
-
       
    () in

     

       
94
       
 
       


     

       
95
       
 
       
  (* Create episode with audio attachment *)

     

       
96
       
-
       
  let attachment = Attachment.create

     

       
97
       
-
       
    ~url:"https://podcast.example.com/episodes/ep1.mp3"

     

       
98
       
-
       
    ~mime_type:"audio/mpeg"

     

       
99
       
-
       
    ~title:"Episode 1: Introduction"

     

       
100
       
-
       
    ~size_in_bytes:15_728_640L

     

       
101
       
-
       
    ~duration_in_seconds:1800

     

       
102
       
-
       
    () in

     

       
103
       
 
       


     

       
104
       
-
       
  let episode = Item.create

     

       
105
       
-
       
    ~id:"https://podcast.example.com/episodes/1"

     

       
106
       
-
       
    ~url:"https://podcast.example.com/episodes/1"

     

       
107
       
-
       
    ~title:"Episode 1: Introduction"

     

       
108
       
-
       
    ~content:(`Html "<p>Welcome to our first episode!</p>")

     

       
109
       
-
       
    ~date_published:(Jsonfeed.Rfc3339.parse "2024-11-01T12:00:00Z" |> Option.get)

     

       
110
       
-
       
    ~attachments:[attachment]

     

       
111
       
-
       
    ~authors:[host]

     

       
112
       
-
       
    ~image:"https://podcast.example.com/episodes/ep1-cover.jpg"

     

       
113
       
-
       
    () in

     

       
114
       
 
       


     

       
115
       
 
       
  (* Create podcast feed with hub for real-time updates *)

     

       
116
       
-
       
  let hub = Hub.create

     

       
117
       
-
       
    ~type_:"WebSub"

     

       
118
       
-
       
    ~url:"https://pubsubhubbub.appspot.com/"

     

       
119
       
-
       
    () in

     

       
120
       
 
       


     

       
121
       
-
       
  let feed = Jsonfeed.create

     

       
122
       
-
       
    ~title:"Example Podcast"

     

       
123
       
-
       
    ~home_page_url:"https://podcast.example.com"

     

       
124
       
-
       
    ~feed_url:"https://podcast.example.com/feed.json"

     

       
125
       
-
       
    ~description:"A podcast about interesting topics"

     

       
126
       
-
       
    ~icon:"https://podcast.example.com/icon.png"

     

       
127
       
-
       
    ~authors:[host]

     

       
128
       
-
       
    ~language:"en-US"

     

       
129
       
-
       
    ~hubs:[hub]

     

       
130
       
-
       
    ~items:[episode]

     

       
131
       
-
       
    () in

     

       
132
       
 
       


     

       
133
       
 
       
  feed

     

       
134
       
 
       


     
···

       
139
       
 
       


     

       
140
       
 
       
  (* Serialize to string *)

     

       
141
       
 
       
  (match Jsonfeed.to_string blog_feed with

     

       
142
       
-
       
   | Ok json_string ->

     

       
143
       
-
       
       Format.printf "JSON (first 200 chars): %s...\n\n"

     

       
144
       
-
       
         (String.sub json_string 0 (min 200 (String.length json_string)))

     

       
145
       
-
       
   | Error e ->

     

       
146
       
-
       
       Printf.eprintf "Error serializing to string: %s\n" (Jsont.Error.to_string e);

     

       
147
       
-
       
       exit 1);

     

       
0
       
 
       

     

       
148
       
 
       


     

       
149
       
 
       
  (* Serialize to file *)

     

       
150
       
 
       
  to_file "blog-feed.json" blog_feed;

     
···

       
156
       
 
       


     

       
157
       
 
       
  (* Validate feeds *)

     

       
158
       
 
       
  (match Jsonfeed.validate blog_feed with

     

       
159
       
-
       
   | Ok () -> Format.printf "✓ Blog feed is valid\n"

     

       
160
       
-
       
   | Error errors ->

     

       
161
       
-
       
       Format.printf "✗ Blog feed validation errors:\n";

     

       
162
       
-
       
       List.iter (Format.printf "  - %s\n") errors);

     

       
163
       
 
       


     

       
164
       
-
       
  (match Jsonfeed.validate podcast_feed with

     

       
165
       
-
       
   | Ok () -> Format.printf "✓ Podcast feed is valid\n"

     

       
166
       
-
       
   | Error errors ->

     

       
167
       
-
       
       Format.printf "✗ Podcast feed validation errors:\n";

     

       
168
       
-
       
       List.iter (Format.printf "  - %s\n") errors)

     

       
169
       
 
       


     

       
170
       
 
       
let () = main ()

     

···

       
13
       
 
       
  match Jsonfeed.to_string feed with

     

       
14
       
 
       
  | Ok s ->

     

       
15
       
 
       
      Out_channel.with_open_gen

     

       
16
       
+
       
        [ Open_wronly; Open_creat; Open_trunc; Open_text ] 0o644 filename

     

       
0
       
 
       

     

       
0
       
 
       

     

       
17
       
 
       
        (fun oc -> Out_channel.output_string oc s)

     

       
18
       
 
       
  | Error e ->

     

       
19
       
 
       
      Printf.eprintf "Error encoding feed: %s\n" (Jsont.Error.to_string e);

     
···

       
21
       
 
       


     

       
22
       
 
       
let create_blog_feed () =

     

       
23
       
 
       
  (* Create some authors *)

     

       
24
       
+
       
  let jane =

     

       
25
       
+
       
    Author.create ~name:"Jane Doe" ~url:"https://example.com/authors/jane"

     

       
26
       
+
       
      ~avatar:"https://example.com/avatars/jane.png" ()

     

       
27
       
+
       
  in

     

       
0
       
 
       

     

       
28
       
 
       


     

       
29
       
+
       
  let john =

     

       
30
       
+
       
    Author.create ~name:"John Smith" ~url:"https://example.com/authors/john" ()

     

       
31
       
+
       
  in

     

       
0
       
 
       

     

       
32
       
 
       


     

       
33
       
 
       
  (* Create items with different content types *)

     

       
34
       
+
       
  let item1 =

     

       
35
       
+
       
    Item.create ~id:"https://example.com/posts/1"

     

       
36
       
+
       
      ~url:"https://example.com/posts/1" ~title:"Introduction to OCaml"

     

       
37
       
+
       
      ~content:

     

       
38
       
+
       
        (`Both

     

       
39
       
+
       
           ( "<p>OCaml is a powerful functional programming language.</p>",

     

       
40
       
+
       
             "OCaml is a powerful functional programming language." ))

     

       
41
       
+
       
      ~date_published:

     

       
42
       
+
       
        (Jsonfeed.Rfc3339.parse "2024-11-01T10:00:00Z" |> Option.get)

     

       
43
       
+
       
      ~date_modified:

     

       
44
       
+
       
        (Jsonfeed.Rfc3339.parse "2024-11-01T15:30:00Z" |> Option.get)

     

       
45
       
+
       
      ~authors:[ jane ]

     

       
46
       
+
       
      ~tags:[ "ocaml"; "programming"; "functional" ]

     

       
47
       
+
       
      ~summary:"A beginner's guide to OCaml programming" ()

     

       
48
       
+
       
  in

     

       
49
       
 
       


     

       
50
       
+
       
  let item2 =

     

       
51
       
+
       
    Item.create ~id:"https://example.com/posts/2"

     

       
52
       
+
       
      ~url:"https://example.com/posts/2" ~title:"JSON Feed for Syndication"

     

       
53
       
+
       
      ~content:

     

       
54
       
+
       
        (`Html "<p>JSON Feed is a modern alternative to RSS and Atom.</p>")

     

       
55
       
+
       
      ~date_published:

     

       
56
       
+
       
        (Jsonfeed.Rfc3339.parse "2024-11-02T09:00:00Z" |> Option.get)

     

       
57
       
+
       
      ~authors:[ jane; john ]

     

       
58
       
+
       
      ~tags:[ "json"; "syndication"; "web" ]

     

       
59
       
+
       
      ~image:"https://example.com/images/jsonfeed.png" ()

     

       
60
       
+
       
  in

     

       
61
       
 
       


     

       
62
       
 
       
  (* Microblog-style item (text only, no title) *)

     

       
63
       
+
       
  let item3 =

     

       
64
       
+
       
    Item.create ~id:"https://example.com/micro/42"

     

       
65
       
+
       
      ~content:(`Text "Just shipped a new feature! 🚀")

     

       
66
       
+
       
      ~date_published:

     

       
67
       
+
       
        (Jsonfeed.Rfc3339.parse "2024-11-03T08:15:00Z" |> Option.get)

     

       
68
       
+
       
      ~tags:[ "microblog" ] ()

     

       
69
       
+
       
  in

     

       
70
       
 
       


     

       
71
       
 
       
  (* Create the complete feed *)

     

       
72
       
+
       
  let feed =

     

       
73
       
+
       
    Jsonfeed.create ~title:"Example Blog" ~home_page_url:"https://example.com"

     

       
74
       
+
       
      ~feed_url:"https://example.com/feed.json"

     

       
75
       
+
       
      ~description:"A blog about programming, web development, and technology"

     

       
76
       
+
       
      ~icon:"https://example.com/icon-512.png"

     

       
77
       
+
       
      ~favicon:"https://example.com/favicon-64.png" ~authors:[ jane; john ]

     

       
78
       
+
       
      ~language:"en-US" ~items:[ item1; item2; item3 ] ()

     

       
79
       
+
       
  in

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
80
       
 
       


     

       
81
       
 
       
  feed

     

       
82
       
 
       


     

       
83
       
 
       
let create_podcast_feed () =

     

       
84
       
 
       
  (* Create podcast author *)

     

       
85
       
+
       
  let host =

     

       
86
       
+
       
    Author.create ~name:"Podcast Host" ~url:"https://podcast.example.com/host"

     

       
87
       
+
       
      ~avatar:"https://podcast.example.com/host-avatar.jpg" ()

     

       
88
       
+
       
  in

     

       
0
       
 
       

     

       
89
       
 
       


     

       
90
       
 
       
  (* Create episode with audio attachment *)

     

       
91
       
+
       
  let attachment =

     

       
92
       
+
       
    Attachment.create ~url:"https://podcast.example.com/episodes/ep1.mp3"

     

       
93
       
+
       
      ~mime_type:"audio/mpeg" ~title:"Episode 1: Introduction"

     

       
94
       
+
       
      ~size_in_bytes:15_728_640L ~duration_in_seconds:1800 ()

     

       
95
       
+
       
  in

     

       
0
       
 
       

     

       
0
       
 
       

     

       
96
       
 
       


     

       
97
       
+
       
  let episode =

     

       
98
       
+
       
    Item.create ~id:"https://podcast.example.com/episodes/1"

     

       
99
       
+
       
      ~url:"https://podcast.example.com/episodes/1"

     

       
100
       
+
       
      ~title:"Episode 1: Introduction"

     

       
101
       
+
       
      ~content:(`Html "<p>Welcome to our first episode!</p>")

     

       
102
       
+
       
      ~date_published:

     

       
103
       
+
       
        (Jsonfeed.Rfc3339.parse "2024-11-01T12:00:00Z" |> Option.get)

     

       
104
       
+
       
      ~attachments:[ attachment ] ~authors:[ host ]

     

       
105
       
+
       
      ~image:"https://podcast.example.com/episodes/ep1-cover.jpg" ()

     

       
106
       
+
       
  in

     

       
107
       
 
       


     

       
108
       
 
       
  (* Create podcast feed with hub for real-time updates *)

     

       
109
       
+
       
  let hub =

     

       
110
       
+
       
    Hub.create ~type_:"WebSub" ~url:"https://pubsubhubbub.appspot.com/" ()

     

       
111
       
+
       
  in

     

       
0
       
 
       

     

       
112
       
 
       


     

       
113
       
+
       
  let feed =

     

       
114
       
+
       
    Jsonfeed.create ~title:"Example Podcast"

     

       
115
       
+
       
      ~home_page_url:"https://podcast.example.com"

     

       
116
       
+
       
      ~feed_url:"https://podcast.example.com/feed.json"

     

       
117
       
+
       
      ~description:"A podcast about interesting topics"

     

       
118
       
+
       
      ~icon:"https://podcast.example.com/icon.png" ~authors:[ host ]

     

       
119
       
+
       
      ~language:"en-US" ~hubs:[ hub ] ~items:[ episode ] ()

     

       
120
       
+
       
  in

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
121
       
 
       


     

       
122
       
 
       
  feed

     

       
123
       
 
       


     
···

       
128
       
 
       


     

       
129
       
 
       
  (* Serialize to string *)

     

       
130
       
 
       
  (match Jsonfeed.to_string blog_feed with

     

       
131
       
+
       
  | Ok json_string ->

     

       
132
       
+
       
      Format.printf "JSON (first 200 chars): %s...\n\n"

     

       
133
       
+
       
        (String.sub json_string 0 (min 200 (String.length json_string)))

     

       
134
       
+
       
  | Error e ->

     

       
135
       
+
       
      Printf.eprintf "Error serializing to string: %s\n"

     

       
136
       
+
       
        (Jsont.Error.to_string e);

     

       
137
       
+
       
      exit 1);

     

       
138
       
 
       


     

       
139
       
 
       
  (* Serialize to file *)

     

       
140
       
 
       
  to_file "blog-feed.json" blog_feed;

     
···

       
146
       
 
       


     

       
147
       
 
       
  (* Validate feeds *)

     

       
148
       
 
       
  (match Jsonfeed.validate blog_feed with

     

       
149
       
+
       
  | Ok () -> Format.printf "✓ Blog feed is valid\n"

     

       
150
       
+
       
  | Error errors ->

     

       
151
       
+
       
      Format.printf "✗ Blog feed validation errors:\n";

     

       
152
       
+
       
      List.iter (Format.printf "  - %s\n") errors);

     

       
153
       
 
       


     

       
154
       
+
       
  match Jsonfeed.validate podcast_feed with

     

       
155
       
+
       
  | Ok () -> Format.printf "✓ Podcast feed is valid\n"

     

       
156
       
+
       
  | Error errors ->

     

       
157
       
+
       
      Format.printf "✗ Podcast feed validation errors:\n";

     

       
158
       
+
       
      List.iter (Format.printf "  - %s\n") errors

     

       
159
       
 
       


     

       
160
       
 
       
let () = main ()

     

···

       
19
       
 
       
  Format.printf "  Version: %s\n" (Jsonfeed.version feed);

     

       
20
       
 
       


     

       
21
       
 
       
  (match Jsonfeed.home_page_url feed with

     

       
22
       
-
       
   | Some url -> Format.printf "  Home Page: %s\n" url

     

       
23
       
-
       
   | None -> ());

     

       
24
       
 
       


     

       
25
       
 
       
  (match Jsonfeed.feed_url feed with

     

       
26
       
-
       
   | Some url -> Format.printf "  Feed URL: %s\n" url

     

       
27
       
-
       
   | None -> ());

     

       
28
       
 
       


     

       
29
       
 
       
  (match Jsonfeed.description feed with

     

       
30
       
-
       
   | Some desc -> Format.printf "  Description: %s\n" desc

     

       
31
       
-
       
   | None -> ());

     

       
32
       
 
       


     

       
33
       
 
       
  (match Jsonfeed.language feed with

     

       
34
       
-
       
   | Some lang -> Format.printf "  Language: %s\n" lang

     

       
35
       
-
       
   | None -> ());

     

       
36
       
 
       


     

       
37
       
 
       
  (match Jsonfeed.authors feed with

     

       
38
       
-
       
   | Some authors ->

     

       
39
       
-
       
       Format.printf "  Authors:\n";

     

       
40
       
-
       
       List.iter (fun author ->

     

       
41
       
-
       
         match Author.name author with

     

       
42
       
-
       
         | Some name -> Format.printf "    - %s" name;

     

       
43
       
-
       
             (match Author.url author with

     

       
0
       
 
       

     

       
0
       
 
       

     

       
44
       
 
       
              | Some url -> Format.printf " (%s)" url

     

       
45
       
 
       
              | None -> ());

     

       
46
       
-
       
             Format.printf "\n"

     

       
47
       
-
       
         | None -> ()

     

       
48
       
-
       
       ) authors

     

       
49
       
-
       
   | None -> ());

     

       
50
       
 
       


     

       
51
       
 
       
  Format.printf "  Items: %d\n\n" (List.length (Jsonfeed.items feed))

     

       
52
       
 
       


     
···

       
54
       
 
       
  Format.printf "Item: %s\n" (Item.id item);

     

       
55
       
 
       


     

       
56
       
 
       
  (match Item.title item with

     

       
57
       
-
       
   | Some title -> Format.printf "  Title: %s\n" title

     

       
58
       
-
       
   | None -> Format.printf "  (No title - microblog entry)\n");

     

       
59
       
 
       


     

       
60
       
 
       
  (match Item.url item with

     

       
61
       
-
       
   | Some url -> Format.printf "  URL: %s\n" url

     

       
62
       
-
       
   | None -> ());

     

       
63
       
 
       


     

       
64
       
 
       
  (* Print content info *)

     

       
65
       
 
       
  (match Item.content item with

     

       
66
       
-
       
   | `Html html ->

     

       
67
       
-
       
       Format.printf "  Content: HTML only (%d chars)\n"

     

       
68
       
-
       
         (String.length html)

     

       
69
       
-
       
   | `Text text ->

     

       
70
       
-
       
       Format.printf "  Content: Text only (%d chars)\n"

     

       
71
       
-
       
         (String.length text)

     

       
72
       
-
       
   | `Both (html, text) ->

     

       
73
       
-
       
       Format.printf "  Content: Both HTML (%d chars) and Text (%d chars)\n"

     

       
74
       
-
       
         (String.length html) (String.length text));

     

       
75
       
 
       


     

       
76
       
 
       
  (* Print dates *)

     

       
77
       
 
       
  (match Item.date_published item with

     

       
78
       
-
       
   | Some date ->

     

       
79
       
-
       
       Format.printf "  Published: %s\n"

     

       
80
       
-
       
         (Jsonfeed.Rfc3339.format date)

     

       
81
       
-
       
   | None -> ());

     

       
82
       
 
       


     

       
83
       
 
       
  (match Item.date_modified item with

     

       
84
       
-
       
   | Some date ->

     

       
85
       
-
       
       Format.printf "  Modified: %s\n"

     

       
86
       
-
       
         (Jsonfeed.Rfc3339.format date)

     

       
87
       
-
       
   | None -> ());

     

       
88
       
 
       


     

       
89
       
 
       
  (* Print tags *)

     

       
90
       
 
       
  (match Item.tags item with

     

       
91
       
-
       
   | Some tags when tags <> [] ->

     

       
92
       
-
       
       Format.printf "  Tags: %s\n" (String.concat ", " tags)

     

       
93
       
-
       
   | _ -> ());

     

       
94
       
 
       


     

       
95
       
 
       
  (* Print attachments *)

     

       
96
       
 
       
  (match Item.attachments item with

     

       
97
       
-
       
   | Some attachments when attachments <> [] ->

     

       
98
       
-
       
       Format.printf "  Attachments:\n";

     

       
99
       
-
       
       List.iter (fun att ->

     

       
100
       
-
       
         Format.printf "    - %s (%s)\n"

     

       
101
       
-
       
           (Attachment.url att)

     

       
102
       
-
       
           (Attachment.mime_type att);

     

       
103
       
-
       
         (match Attachment.size_in_bytes att with

     

       
104
       
 
       
          | Some size ->

     

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

     

       
106
       
 
       
              Format.printf "      Size: %.2f MB\n" mb

     

       
107
       
 
       
          | None -> ());

     

       
108
       
-
       
         (match Attachment.duration_in_seconds att with

     

       
109
       
 
       
          | Some duration ->

     

       
110
       
 
       
              let mins = duration / 60 in

     

       
111
       
 
       
              let secs = duration mod 60 in

     

       
112
       
 
       
              Format.printf "      Duration: %dm%ds\n" mins secs

     

       
113
       
 
       
          | None -> ())

     

       
114
       
-
       
       ) attachments

     

       
115
       
-
       
   | _ -> ());

     

       
116
       
 
       


     

       
117
       
 
       
  Format.printf "\n"

     

       
118
       
 
       


     
···

       
126
       
 
       
  let text_only = ref 0 in

     

       
127
       
 
       
  let both = ref 0 in

     

       
128
       
 
       


     

       
129
       
-
       
  List.iter (fun item ->

     

       
130
       
-
       
    match Item.content item with

     

       
131
       
-
       
    | `Html _ -> incr html_only

     

       
132
       
-
       
    | `Text _ -> incr text_only

     

       
133
       
-
       
    | `Both _ -> incr both

     

       
134
       
-
       
  ) items;

     

       
0
       
 
       

     

       
135
       
 
       


     

       
136
       
 
       
  Format.printf "Content Types:\n";

     

       
137
       
 
       
  Format.printf "  HTML only: %d\n" !html_only;

     
···

       
139
       
 
       
  Format.printf "  Both: %d\n\n" !both;

     

       
140
       
 
       


     

       
141
       
 
       
  (* Find items with attachments *)

     

       
142
       
-
       
  let with_attachments = List.filter (fun item ->

     

       
143
       
-
       
    match Item.attachments item with

     

       
144
       
-
       
    | Some att when att <> [] -> true

     

       
145
       
-
       
    | _ -> false

     

       
146
       
-
       
  ) items in

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
147
       
 
       


     

       
148
       
 
       
  Format.printf "Items with attachments: %d\n\n" (List.length with_attachments);

     

       
149
       
 
       


     

       
150
       
 
       
  (* Collect all unique tags *)

     

       
151
       
-
       
  let all_tags = List.fold_left (fun acc item ->

     

       
152
       
-
       
    match Item.tags item with

     

       
153
       
-
       
    | Some tags -> acc @ tags

     

       
154
       
-
       
    | None -> acc

     

       
155
       
-
       
  ) [] items in

     

       
0
       
 
       

     

       
156
       
 
       
  let unique_tags = List.sort_uniq String.compare all_tags in

     

       
157
       
 
       


     

       
158
       
-
       
  if unique_tags <> [] then (

     

       
159
       
 
       
    Format.printf "All tags used: %s\n\n" (String.concat ", " unique_tags)

     

       
160
       
-
       
  )

     

       
161
       
 
       


     

       
162
       
 
       
let main () =

     

       
163
       
 
       
  (* Parse from example_feed.json file *)

     

       
164
       
 
       
  Format.printf "=== Parsing JSON Feed from example_feed.json ===\n\n";

     

       
165
       
 
       


     

       
166
       
-
       
  (try

     

       
167
       
 
       
    match of_file "example/example_feed.json" with

     

       
168
       
-
       
    | Ok feed ->

     

       
169
       
 
       
        print_feed_info feed;

     

       
170
       
 
       


     

       
171
       
 
       
        Format.printf "=== Items ===\n\n";

     
···

       
175
       
 
       


     

       
176
       
 
       
        (* Demonstrate round-trip parsing *)

     

       
177
       
 
       
        Format.printf "\n=== Round-trip Test ===\n\n";

     

       
178
       
-
       
        (match Jsonfeed.to_string feed with

     

       
179
       
-
       
         | Error e ->

     

       
180
       
-
       
             Printf.eprintf "Error serializing feed: %s\n" (Jsont.Error.to_string e);

     

       
181
       
-
       
             exit 1

     

       
182
       
-
       
         | Ok json ->

     

       
183
       
-
       
             match Jsonfeed.of_string json with

     

       
184
       
-
       
             | Ok feed2 ->

     

       
185
       
-
       
                 if Jsonfeed.equal feed feed2 then

     

       
186
       
-
       
                   Format.printf "✓ Round-trip successful: feeds are equal\n"

     

       
187
       
-
       
                 else

     

       
188
       
-
       
                   Format.printf "✗ Round-trip failed: feeds differ\n"

     

       
189
       
-
       
             | Error err ->

     

       
190
       
-
       
                 Format.eprintf "✗ Round-trip failed: %s\n" (Jsont.Error.to_string err))

     

       
0
       
 
       

     

       
191
       
 
       
    | Error err ->

     

       
192
       
 
       
        Format.eprintf "Error parsing feed: %s\n" (Jsont.Error.to_string err)

     

       
193
       
-
       
  with

     

       
194
       
-
       
   | Sys_error msg ->

     

       
195
       
-
       
       Format.eprintf "Error reading file: %s\n" msg)

     

       
196
       
 
       


     

       
197
       
 
       
let () = main ()

     

···

       
19
       
 
       
  Format.printf "  Version: %s\n" (Jsonfeed.version feed);

     

       
20
       
 
       


     

       
21
       
 
       
  (match Jsonfeed.home_page_url feed with

     

       
22
       
+
       
  | Some url -> Format.printf "  Home Page: %s\n" url

     

       
23
       
+
       
  | None -> ());

     

       
24
       
 
       


     

       
25
       
 
       
  (match Jsonfeed.feed_url feed with

     

       
26
       
+
       
  | Some url -> Format.printf "  Feed URL: %s\n" url

     

       
27
       
+
       
  | None -> ());

     

       
28
       
 
       


     

       
29
       
 
       
  (match Jsonfeed.description feed with

     

       
30
       
+
       
  | Some desc -> Format.printf "  Description: %s\n" desc

     

       
31
       
+
       
  | None -> ());

     

       
32
       
 
       


     

       
33
       
 
       
  (match Jsonfeed.language feed with

     

       
34
       
+
       
  | Some lang -> Format.printf "  Language: %s\n" lang

     

       
35
       
+
       
  | None -> ());

     

       
36
       
 
       


     

       
37
       
 
       
  (match Jsonfeed.authors feed with

     

       
38
       
+
       
  | Some authors ->

     

       
39
       
+
       
      Format.printf "  Authors:\n";

     

       
40
       
+
       
      List.iter

     

       
41
       
+
       
        (fun author ->

     

       
42
       
+
       
          match Author.name author with

     

       
43
       
+
       
          | Some name ->

     

       
44
       
+
       
              Format.printf "    - %s" name;

     

       
45
       
+
       
              (match Author.url author with

     

       
46
       
 
       
              | Some url -> Format.printf " (%s)" url

     

       
47
       
 
       
              | None -> ());

     

       
48
       
+
       
              Format.printf "\n"

     

       
49
       
+
       
          | None -> ())

     

       
50
       
+
       
        authors

     

       
51
       
+
       
  | None -> ());

     

       
52
       
 
       


     

       
53
       
 
       
  Format.printf "  Items: %d\n\n" (List.length (Jsonfeed.items feed))

     

       
54
       
 
       


     
···

       
56
       
 
       
  Format.printf "Item: %s\n" (Item.id item);

     

       
57
       
 
       


     

       
58
       
 
       
  (match Item.title item with

     

       
59
       
+
       
  | Some title -> Format.printf "  Title: %s\n" title

     

       
60
       
+
       
  | None -> Format.printf "  (No title - microblog entry)\n");

     

       
61
       
 
       


     

       
62
       
 
       
  (match Item.url item with

     

       
63
       
+
       
  | Some url -> Format.printf "  URL: %s\n" url

     

       
64
       
+
       
  | None -> ());

     

       
65
       
 
       


     

       
66
       
 
       
  (* Print content info *)

     

       
67
       
 
       
  (match Item.content item with

     

       
68
       
+
       
  | `Html html ->

     

       
69
       
+
       
      Format.printf "  Content: HTML only (%d chars)\n" (String.length html)

     

       
70
       
+
       
  | `Text text ->

     

       
71
       
+
       
      Format.printf "  Content: Text only (%d chars)\n" (String.length text)

     

       
72
       
+
       
  | `Both (html, text) ->

     

       
73
       
+
       
      Format.printf "  Content: Both HTML (%d chars) and Text (%d chars)\n"

     

       
74
       
+
       
        (String.length html) (String.length text));

     

       
0
       
 
       

     

       
0
       
 
       

     

       
75
       
 
       


     

       
76
       
 
       
  (* Print dates *)

     

       
77
       
 
       
  (match Item.date_published item with

     

       
78
       
+
       
  | Some date ->

     

       
79
       
+
       
      Format.printf "  Published: %s\n" (Jsonfeed.Rfc3339.format date)

     

       
80
       
+
       
  | None -> ());

     

       
0
       
 
       

     

       
81
       
 
       


     

       
82
       
 
       
  (match Item.date_modified item with

     

       
83
       
+
       
  | Some date -> Format.printf "  Modified: %s\n" (Jsonfeed.Rfc3339.format date)

     

       
84
       
+
       
  | None -> ());

     

       
0
       
 
       

     

       
0
       
 
       

     

       
85
       
 
       


     

       
86
       
 
       
  (* Print tags *)

     

       
87
       
 
       
  (match Item.tags item with

     

       
88
       
+
       
  | Some tags when tags <> [] ->

     

       
89
       
+
       
      Format.printf "  Tags: %s\n" (String.concat ", " tags)

     

       
90
       
+
       
  | _ -> ());

     

       
91
       
 
       


     

       
92
       
 
       
  (* Print attachments *)

     

       
93
       
 
       
  (match Item.attachments item with

     

       
94
       
+
       
  | Some attachments when attachments <> [] ->

     

       
95
       
+
       
      Format.printf "  Attachments:\n";

     

       
96
       
+
       
      List.iter

     

       
97
       
+
       
        (fun att ->

     

       
98
       
+
       
          Format.printf "    - %s (%s)\n" (Attachment.url att)

     

       
99
       
+
       
            (Attachment.mime_type att);

     

       
100
       
+
       
          (match Attachment.size_in_bytes att with

     

       
101
       
 
       
          | Some size ->

     

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

     

       
103
       
 
       
              Format.printf "      Size: %.2f MB\n" mb

     

       
104
       
 
       
          | None -> ());

     

       
105
       
+
       
          match Attachment.duration_in_seconds att with

     

       
106
       
 
       
          | Some duration ->

     

       
107
       
 
       
              let mins = duration / 60 in

     

       
108
       
 
       
              let secs = duration mod 60 in

     

       
109
       
 
       
              Format.printf "      Duration: %dm%ds\n" mins secs

     

       
110
       
 
       
          | None -> ())

     

       
111
       
+
       
        attachments

     

       
112
       
+
       
  | _ -> ());

     

       
113
       
 
       


     

       
114
       
 
       
  Format.printf "\n"

     

       
115
       
 
       


     
···

       
123
       
 
       
  let text_only = ref 0 in

     

       
124
       
 
       
  let both = ref 0 in

     

       
125
       
 
       


     

       
126
       
+
       
  List.iter

     

       
127
       
+
       
    (fun item ->

     

       
128
       
+
       
      match Item.content item with

     

       
129
       
+
       
      | `Html _ -> incr html_only

     

       
130
       
+
       
      | `Text _ -> incr text_only

     

       
131
       
+
       
      | `Both _ -> incr both)

     

       
132
       
+
       
    items;

     

       
133
       
 
       


     

       
134
       
 
       
  Format.printf "Content Types:\n";

     

       
135
       
 
       
  Format.printf "  HTML only: %d\n" !html_only;

     
···

       
137
       
 
       
  Format.printf "  Both: %d\n\n" !both;

     

       
138
       
 
       


     

       
139
       
 
       
  (* Find items with attachments *)

     

       
140
       
+
       
  let with_attachments =

     

       
141
       
+
       
    List.filter

     

       
142
       
+
       
      (fun item ->

     

       
143
       
+
       
        match Item.attachments item with

     

       
144
       
+
       
        | Some att when att <> [] -> true

     

       
145
       
+
       
        | _ -> false)

     

       
146
       
+
       
      items

     

       
147
       
+
       
  in

     

       
148
       
 
       


     

       
149
       
 
       
  Format.printf "Items with attachments: %d\n\n" (List.length with_attachments);

     

       
150
       
 
       


     

       
151
       
 
       
  (* Collect all unique tags *)

     

       
152
       
+
       
  let all_tags =

     

       
153
       
+
       
    List.fold_left

     

       
154
       
+
       
      (fun acc item ->

     

       
155
       
+
       
        match Item.tags item with Some tags -> acc @ tags | None -> acc)

     

       
156
       
+
       
      [] items

     

       
157
       
+
       
  in

     

       
158
       
 
       
  let unique_tags = List.sort_uniq String.compare all_tags in

     

       
159
       
 
       


     

       
160
       
+
       
  if unique_tags <> [] then

     

       
161
       
 
       
    Format.printf "All tags used: %s\n\n" (String.concat ", " unique_tags)

     

       
0
       
 
       

     

       
162
       
 
       


     

       
163
       
 
       
let main () =

     

       
164
       
 
       
  (* Parse from example_feed.json file *)

     

       
165
       
 
       
  Format.printf "=== Parsing JSON Feed from example_feed.json ===\n\n";

     

       
166
       
 
       


     

       
167
       
+
       
  try

     

       
168
       
 
       
    match of_file "example/example_feed.json" with

     

       
169
       
+
       
    | Ok feed -> (

     

       
170
       
 
       
        print_feed_info feed;

     

       
171
       
 
       


     

       
172
       
 
       
        Format.printf "=== Items ===\n\n";

     
···

       
176
       
 
       


     

       
177
       
 
       
        (* Demonstrate round-trip parsing *)

     

       
178
       
 
       
        Format.printf "\n=== Round-trip Test ===\n\n";

     

       
179
       
+
       
        match Jsonfeed.to_string feed with

     

       
180
       
+
       
        | Error e ->

     

       
181
       
+
       
            Printf.eprintf "Error serializing feed: %s\n"

     

       
182
       
+
       
              (Jsont.Error.to_string e);

     

       
183
       
+
       
            exit 1

     

       
184
       
+
       
        | Ok json -> (

     

       
185
       
+
       
            match Jsonfeed.of_string json with

     

       
186
       
+
       
            | Ok feed2 ->

     

       
187
       
+
       
                if Jsonfeed.equal feed feed2 then

     

       
188
       
+
       
                  Format.printf "✓ Round-trip successful: feeds are equal\n"

     

       
189
       
+
       
                else Format.printf "✗ Round-trip failed: feeds differ\n"

     

       
190
       
+
       
            | Error err ->

     

       
191
       
+
       
                Format.eprintf "✗ Round-trip failed: %s\n"

     

       
192
       
+
       
                  (Jsont.Error.to_string err)))

     

       
193
       
 
       
    | Error err ->

     

       
194
       
 
       
        Format.eprintf "Error parsing feed: %s\n" (Jsont.Error.to_string err)

     

       
195
       
+
       
  with Sys_error msg -> Format.eprintf "Error reading file: %s\n" msg

     

       
0
       
 
       

     

       
0
       
 
       

     

       
196
       
 
       


     

       
197
       
 
       
let () = main ()

     

···

       
1
       
-
       
(** Example: Validating JSON Feeds

     

       
2
       
-
       


     

       
3
       
-
       
    This demonstrates:

     

       
4
       
-
       
    - Validating feed structure

     

       
5
       
-
       
    - Testing various edge cases

     

       
6
       
-
       
    - Handling invalid feeds

     

       
7
       
-
       
    - Best practices for feed construction *)

     

       
8
       
-
       


     

       
9
       
-
       
open Jsonfeed

     

       
10
       
-
       


     

       
11
       
-
       
let test_valid_minimal_feed () =

     

       
12
       
-
       
  Format.printf "=== Test: Minimal Valid Feed ===\n";

     

       
13
       
-
       


     

       
14
       
-
       
  let feed = Jsonfeed.create

     

       
15
       
-
       
    ~title:"Minimal Feed"

     

       
16
       
-
       
    ~items:[]

     

       
17
       
-
       
    () in

     

       
18
       
-
       


     

       
19
       
-
       
  match Jsonfeed.validate feed with

     

       
20
       
-
       
  | Ok () -> Format.printf "✓ Minimal feed is valid\n\n"

     

       
21
       
-
       
  | Error errors ->

     

       
22
       
-
       
      Format.printf "✗ Minimal feed validation failed:\n";

     

       
23
       
-
       
      List.iter (Format.printf "  - %s\n") errors;

     

       
24
       
-
       
      Format.printf "\n"

     

       
25
       
-
       


     

       
26
       
-
       
let test_valid_complete_feed () =

     

       
27
       
-
       
  Format.printf "=== Test: Complete Valid Feed ===\n";

     

       
28
       
-
       


     

       
29
       
-
       
  let author = Author.create

     

       
30
       
-
       
    ~name:"Test Author"

     

       
31
       
-
       
    ~url:"https://example.com/author"

     

       
32
       
-
       
    ~avatar:"https://example.com/avatar.png"

     

       
33
       
-
       
    () in

     

       
34
       
-
       


     

       
35
       
-
       
  let attachment = Attachment.create

     

       
36
       
-
       
    ~url:"https://example.com/file.mp3"

     

       
37
       
-
       
    ~mime_type:"audio/mpeg"

     

       
38
       
-
       
    ~title:"Audio File"

     

       
39
       
-
       
    ~size_in_bytes:1024L

     

       
40
       
-
       
    ~duration_in_seconds:60

     

       
41
       
-
       
    () in

     

       
42
       
-
       


     

       
43
       
-
       
  let item = Item.create

     

       
44
       
-
       
    ~id:"https://example.com/items/1"

     

       
45
       
-
       
    ~url:"https://example.com/items/1"

     

       
46
       
-
       
    ~title:"Test Item"

     

       
47
       
-
       
    ~content:(`Both ("<p>HTML content</p>", "Text content"))

     

       
48
       
-
       
    ~summary:"A test item"

     

       
49
       
-
       
    ~image:"https://example.com/image.jpg"

     

       
50
       
-
       
    ~banner_image:"https://example.com/banner.jpg"

     

       
51
       
-
       
    ~date_published:(Jsonfeed.Rfc3339.parse "2024-11-01T10:00:00Z" |> Option.get)

     

       
52
       
-
       
    ~date_modified:(Jsonfeed.Rfc3339.parse "2024-11-01T15:00:00Z" |> Option.get)

     

       
53
       
-
       
    ~authors:[author]

     

       
54
       
-
       
    ~tags:["test"; "example"]

     

       
55
       
-
       
    ~language:"en"

     

       
56
       
-
       
    ~attachments:[attachment]

     

       
57
       
-
       
    () in

     

       
58
       
-
       


     

       
59
       
-
       
  let hub = Hub.create

     

       
60
       
-
       
    ~type_:"WebSub"

     

       
61
       
-
       
    ~url:"https://pubsubhubbub.appspot.com/"

     

       
62
       
-
       
    () in

     

       
63
       
-
       


     

       
64
       
-
       
  let feed = Jsonfeed.create

     

       
65
       
-
       
    ~title:"Complete Feed"

     

       
66
       
-
       
    ~home_page_url:"https://example.com"

     

       
67
       
-
       
    ~feed_url:"https://example.com/feed.json"

     

       
68
       
-
       
    ~description:"A complete test feed"

     

       
69
       
-
       
    ~user_comment:"This is a test feed"

     

       
70
       
-
       
    ~icon:"https://example.com/icon.png"

     

       
71
       
-
       
    ~favicon:"https://example.com/favicon.ico"

     

       
72
       
-
       
    ~authors:[author]

     

       
73
       
-
       
    ~language:"en-US"

     

       
74
       
-
       
    ~hubs:[hub]

     

       
75
       
-
       
    ~items:[item]

     

       
76
       
-
       
    () in

     

       
77
       
-
       


     

       
78
       
-
       
  match Jsonfeed.validate feed with

     

       
79
       
-
       
  | Ok () -> Format.printf "✓ Complete feed is valid\n\n"

     

       
80
       
-
       
  | Error errors ->

     

       
81
       
-
       
      Format.printf "✗ Complete feed validation failed:\n";

     

       
82
       
-
       
      List.iter (Format.printf "  - %s\n") errors;

     

       
83
       
-
       
      Format.printf "\n"

     

       
84
       
-
       


     

       
85
       
-
       
let test_feed_with_multiple_items () =

     

       
86
       
-
       
  Format.printf "=== Test: Feed with Multiple Items ===\n";

     

       
87
       
-
       


     

       
88
       
-
       
  let items = List.init 10 (fun i ->

     

       
89
       
-
       
    Item.create

     

       
90
       
-
       
      ~id:(Printf.sprintf "https://example.com/items/%d" i)

     

       
91
       
-
       
      ~content:(`Text (Printf.sprintf "Item %d content" i))

     

       
92
       
-
       
      ~title:(Printf.sprintf "Item %d" i)

     

       
93
       
-
       
      ~date_published:(Jsonfeed.Rfc3339.parse

     

       
94
       
-
       
        (Printf.sprintf "2024-11-%02dT10:00:00Z" (i + 1)) |> Option.get)

     

       
95
       
-
       
      ()

     

       
96
       
-
       
  ) in

     

       
97
       
-
       


     

       
98
       
-
       
  let feed = Jsonfeed.create

     

       
99
       
-
       
    ~title:"Multi-item Feed"

     

       
100
       
-
       
    ~items

     

       
101
       
-
       
    () in

     

       
102
       
-
       


     

       
103
       
-
       
  match Jsonfeed.validate feed with

     

       
104
       
-
       
  | Ok () ->

     

       
105
       
-
       
      Format.printf "✓ Feed with %d items is valid\n\n" (List.length items)

     

       
106
       
-
       
  | Error errors ->

     

       
107
       
-
       
      Format.printf "✗ Multi-item feed validation failed:\n";

     

       
108
       
-
       
      List.iter (Format.printf "  - %s\n") errors;

     

       
109
       
-
       
      Format.printf "\n"

     

       
110
       
-
       


     

       
111
       
-
       
let test_podcast_feed () =

     

       
112
       
-
       
  Format.printf "=== Test: Podcast Feed ===\n";

     

       
113
       
-
       


     

       
114
       
-
       
  let host = Author.create

     

       
115
       
-
       
    ~name:"Podcast Host"

     

       
116
       
-
       
    ~url:"https://podcast.example.com/host"

     

       
117
       
-
       
    () in

     

       
118
       
-
       


     

       
119
       
-
       
  let episode1 = Attachment.create

     

       
120
       
-
       
    ~url:"https://podcast.example.com/ep1.mp3"

     

       
121
       
-
       
    ~mime_type:"audio/mpeg"

     

       
122
       
-
       
    ~title:"Episode 1"

     

       
123
       
-
       
    ~size_in_bytes:20_971_520L  (* 20 MB *)

     

       
124
       
-
       
    ~duration_in_seconds:1800    (* 30 minutes *)

     

       
125
       
-
       
    () in

     

       
126
       
-
       


     

       
127
       
-
       
  (* Alternate format of the same episode *)

     

       
128
       
-
       
  let episode1_aac = Attachment.create

     

       
129
       
-
       
    ~url:"https://podcast.example.com/ep1.aac"

     

       
130
       
-
       
    ~mime_type:"audio/aac"

     

       
131
       
-
       
    ~title:"Episode 1"

     

       
132
       
-
       
    ~size_in_bytes:16_777_216L

     

       
133
       
-
       
    ~duration_in_seconds:1800

     

       
134
       
-
       
    () in

     

       
135
       
-
       


     

       
136
       
-
       
  let item = Item.create

     

       
137
       
-
       
    ~id:"https://podcast.example.com/episodes/1"

     

       
138
       
-
       
    ~url:"https://podcast.example.com/episodes/1"

     

       
139
       
-
       
    ~title:"Episode 1: Introduction"

     

       
140
       
-
       
    ~content:(`Html "<p>Welcome to the first episode!</p>")

     

       
141
       
-
       
    ~date_published:(Jsonfeed.Rfc3339.parse "2024-11-01T12:00:00Z" |> Option.get)

     

       
142
       
-
       
    ~authors:[host]

     

       
143
       
-
       
    ~attachments:[episode1; episode1_aac]

     

       
144
       
-
       
    ~image:"https://podcast.example.com/ep1-cover.jpg"

     

       
145
       
-
       
    () in

     

       
146
       
-
       


     

       
147
       
-
       
  let feed = Jsonfeed.create

     

       
148
       
-
       
    ~title:"Example Podcast"

     

       
149
       
-
       
    ~home_page_url:"https://podcast.example.com"

     

       
150
       
-
       
    ~feed_url:"https://podcast.example.com/feed.json"

     

       
151
       
-
       
    ~authors:[host]

     

       
152
       
-
       
    ~items:[item]

     

       
153
       
-
       
    () in

     

       
154
       
-
       


     

       
155
       
-
       
  match Jsonfeed.validate feed with

     

       
156
       
-
       
  | Ok () -> Format.printf "✓ Podcast feed is valid\n\n"

     

       
157
       
-
       
  | Error errors ->

     

       
158
       
-
       
      Format.printf "✗ Podcast feed validation failed:\n";

     

       
159
       
-
       
      List.iter (Format.printf "  - %s\n") errors;

     

       
160
       
-
       
      Format.printf "\n"

     

       
161
       
-
       


     

       
162
       
-
       
let test_microblog_feed () =

     

       
163
       
-
       
  Format.printf "=== Test: Microblog Feed (no titles) ===\n";

     

       
164
       
 
       


     

       
165
       
-
       
  let author = Author.create

     

       
166
       
-
       
    ~name:"Microblogger"

     

       
167
       
-
       
    ~url:"https://micro.example.com"

     

       
168
       
-
       
    () in

     

       
169
       
 
       


     

       
170
       
-
       
  let items = [

     

       
171
       
-
       
    Item.create

     

       
172
       
-
       
      ~id:"https://micro.example.com/1"

     

       
173
       
-
       
      ~content:(`Text "Just posted a new photo!")

     

       
174
       
-
       
      ~date_published:(Jsonfeed.Rfc3339.parse "2024-11-01T08:00:00Z" |> Option.get)

     

       
175
       
-
       
      ();

     

       
176
       
-
       
    Item.create

     

       
177
       
-
       
      ~id:"https://micro.example.com/2"

     

       
178
       
-
       
      ~content:(`Text "Having a great day! ☀️")

     

       
179
       
-
       
      ~date_published:(Jsonfeed.Rfc3339.parse "2024-11-01T12:30:00Z" |> Option.get)

     

       
180
       
-
       
      ();

     

       
181
       
-
       
    Item.create

     

       
182
       
-
       
      ~id:"https://micro.example.com/3"

     

       
183
       
-
       
      ~content:(`Html "<p>Check out this <a href=\"#\">link</a></p>")

     

       
184
       
-
       
      ~date_published:(Jsonfeed.Rfc3339.parse "2024-11-01T16:45:00Z" |> Option.get)

     

       
185
       
-
       
      ()

     

       
186
       
-
       
  ] in

     

       
187
       
-
       


     

       
188
       
-
       
  let feed = Jsonfeed.create

     

       
189
       
-
       
    ~title:"Microblog"

     

       
190
       
-
       
    ~home_page_url:"https://micro.example.com"

     

       
191
       
-
       
    ~authors:[author]

     

       
192
       
-
       
    ~items

     

       
193
       
-
       
    () in

     

       
194
       
-
       


     

       
195
       
-
       
  match Jsonfeed.validate feed with

     

       
196
       
-
       
  | Ok () ->

     

       
197
       
-
       
      Format.printf "✓ Microblog feed with %d items is valid\n\n"

     

       
198
       
-
       
        (List.length items)

     

       
199
       
-
       
  | Error errors ->

     

       
200
       
-
       
      Format.printf "✗ Microblog feed validation failed:\n";

     

       
201
       
-
       
      List.iter (Format.printf "  - %s\n") errors;

     

       
202
       
-
       
      Format.printf "\n"

     

       
203
       
-
       


     

       
204
       
-
       
let test_expired_feed () =

     

       
205
       
-
       
  Format.printf "=== Test: Expired Feed ===\n";

     

       
206
       
 
       


     

       
207
       
-
       
  let feed = Jsonfeed.create

     

       
208
       
-
       
    ~title:"Archived Blog"

     

       
209
       
-
       
    ~home_page_url:"https://archive.example.com"

     

       
210
       
-
       
    ~description:"This blog is no longer updated"

     

       
211
       
-
       
    ~expired:true

     

       
212
       
-
       
    ~items:[]

     

       
213
       
-
       
    () in

     

       
214
       
 
       


     

       
215
       
-
       
  match Jsonfeed.validate feed with

     

       
216
       
-
       
  | Ok () -> Format.printf "✓ Expired feed is valid\n\n"

     

       
217
       
-
       
  | Error errors ->

     

       
218
       
-
       
      Format.printf "✗ Expired feed validation failed:\n";

     

       
219
       
-
       
      List.iter (Format.printf "  - %s\n") errors;

     

       
220
       
-
       
      Format.printf "\n"

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
221
       
 
       


     

       
222
       
-
       
let test_paginated_feed () =

     

       
223
       
-
       
  Format.printf "=== Test: Paginated Feed ===\n";

     

       
224
       
-
       


     

       
225
       
-
       
  let items = List.init 25 (fun i ->

     

       
226
       
-
       
    Item.create

     

       
227
       
-
       
      ~id:(Printf.sprintf "https://example.com/items/%d" i)

     

       
228
       
-
       
      ~content:(`Text (Printf.sprintf "Item %d" i))

     

       
229
       
-
       
      ()

     

       
230
       
-
       
  ) in

     

       
231
       
-
       


     

       
232
       
-
       
  let feed = Jsonfeed.create

     

       
233
       
-
       
    ~title:"Large Feed"

     

       
234
       
-
       
    ~home_page_url:"https://example.com"

     

       
235
       
-
       
    ~feed_url:"https://example.com/feed.json?page=1"

     

       
236
       
-
       
    ~next_url:"https://example.com/feed.json?page=2"

     

       
237
       
-
       
    ~items

     

       
238
       
-
       
    () in

     

       
239
       
-
       


     

       
240
       
-
       
  match Jsonfeed.validate feed with

     

       
241
       
-
       
  | Ok () ->

     

       
242
       
-
       
      Format.printf "✓ Paginated feed is valid (page 1 with next_url)\n\n"

     

       
243
       
-
       
  | Error errors ->

     

       
244
       
-
       
      Format.printf "✗ Paginated feed validation failed:\n";

     

       
245
       
-
       
      List.iter (Format.printf "  - %s\n") errors;

     

       
246
       
-
       
      Format.printf "\n"

     

       
247
       
-
       


     

       
248
       
-
       
let test_invalid_feed_from_json () =

     

       
249
       
-
       
  Format.printf "=== Test: Parsing Invalid JSON ===\n";

     

       
250
       
-
       


     

       
251
       
-
       
  (* Missing required version field *)

     

       
252
       
-
       
  let invalid_json1 = {|{

     

       
253
       
-
       
    "title": "Test",

     

       
254
       
-
       
    "items": []

     

       
255
       
-
       
  }|} in

     

       
256
       
-
       


     

       
257
       
-
       
  (match Jsonfeed.of_string invalid_json1 with

     

       
258
       
-
       
   | Ok _ -> Format.printf "✗ Should have failed (missing version)\n"

     

       
259
       
-
       
   | Error err ->

     

       
260
       
-
       
       Format.printf "✓ Correctly rejected invalid feed: %s\n" (Jsont.Error.to_string err));

     

       
261
       
-
       


     

       
262
       
-
       
  (* Missing required title field *)

     

       
263
       
-
       
  let invalid_json2 = {|{

     

       
264
       
-
       
    "version": "https://jsonfeed.org/version/1.1",

     

       
265
       
-
       
    "items": []

     

       
266
       
-
       
  }|} in

     

       
267
       
-
       


     

       
268
       
-
       
  (match Jsonfeed.of_string invalid_json2 with

     

       
269
       
-
       
   | Ok _ -> Format.printf "✗ Should have failed (missing title)\n"

     

       
270
       
-
       
   | Error err ->

     

       
271
       
-
       
       Format.printf "✓ Correctly rejected invalid feed: %s\n" (Jsont.Error.to_string err));

     

       
272
       
-
       


     

       
273
       
-
       
  (* Item without id *)

     

       
274
       
-
       
  let invalid_json3 = {|{

     

       
275
       
-
       
    "version": "https://jsonfeed.org/version/1.1",

     

       
276
       
-
       
    "title": "Test",

     

       
277
       
-
       
    "items": [{

     

       
278
       
-
       
      "content_text": "Hello"

     

       
279
       
-
       
    }]

     

       
280
       
-
       
  }|} in

     

       
281
       
-
       


     

       
282
       
-
       
  (match Jsonfeed.of_string invalid_json3 with

     

       
283
       
-
       
   | Ok _ -> Format.printf "✗ Should have failed (item without id)\n"

     

       
284
       
-
       
   | Error err ->

     

       
285
       
-
       
       Format.printf "✓ Correctly rejected invalid feed: %s\n" (Jsont.Error.to_string err));

     

       
286
       
-
       


     

       
287
       
-
       
  Format.printf "\n"

     

       
288
       
-
       


     

       
289
       
-
       
let main () =

     

       
290
       
-
       
  Format.printf "\n=== JSON Feed Validation Tests ===\n\n";

     

       
291
       
-
       


     

       
292
       
-
       
  test_valid_minimal_feed ();

     

       
293
       
-
       
  test_valid_complete_feed ();

     

       
294
       
-
       
  test_feed_with_multiple_items ();

     

       
295
       
-
       
  test_podcast_feed ();

     

       
296
       
-
       
  test_microblog_feed ();

     

       
297
       
-
       
  test_expired_feed ();

     

       
298
       
-
       
  test_paginated_feed ();

     

       
299
       
-
       
  test_invalid_feed_from_json ();

     

       
300
       
-
       


     

       
301
       
-
       
  Format.printf "=== All Tests Complete ===\n"

     

       
302
       
-
       


     

       
303
       
-
       
let () = main ()

     

···

       
1
       
+
       
(** Example: JSON Feed Validator

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2
       
 
       


     

       
3
       
+
       
    Reads a JSON Feed from stdin and validates it.

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4
       
 
       


     

       
5
       
+
       
    Usage: feed_validator < feed.json cat feed.json | feed_validator

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
6
       
 
       


     

       
7
       
+
       
    Exit codes: 0 - Feed is valid 1 - Feed parsing failed 2 - Feed validation

     

       
8
       
+
       
    failed *)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
9
       
 
       


     

       
10
       
+
       
let validate_stdin () =

     

       
11
       
+
       
  let stdin = Bytesrw.Bytes.Reader.of_in_channel In_channel.stdin in

     

       
12
       
+
       
  match Jsonfeed.decode ~locs:true stdin with

     

       
13
       
+
       
  | Error err ->

     

       
14
       
+
       
      Format.eprintf "Parsing failed:\n  %s\n%!" (Jsont.Error.to_string err);

     

       
15
       
+
       
      exit 1

     

       
16
       
+
       
  | Ok feed -> (

     

       
17
       
+
       
      match Jsonfeed.validate feed with

     

       
18
       
+
       
      | Ok () ->

     

       
19
       
+
       
          Format.printf "Feed is valid\n%!";

     

       
20
       
+
       
          Format.printf "\nFeed details:\n";

     

       
21
       
+
       
          Format.printf "  Title: %s\n" (Jsonfeed.title feed);

     

       
22
       
+
       
          Format.printf "  Version: %s\n" (Jsonfeed.version feed);

     

       
23
       
+
       
          (match Jsonfeed.home_page_url feed with

     

       
24
       
+
       
          | Some url -> Format.printf "  Home page: %s\n" url

     

       
25
       
+
       
          | None -> ());

     

       
26
       
+
       
          Format.printf "  Items: %d\n" (List.length (Jsonfeed.items feed));

     

       
27
       
+
       
          exit 0

     

       
28
       
+
       
      | Error errors ->

     

       
29
       
+
       
          Format.eprintf "Validation failed:\n%!";

     

       
30
       
+
       
          List.iter (fun err -> Format.eprintf "  - %s\n%!" err) errors;

     

       
31
       
+
       
          exit 2)

     

       
32
       
 
       


     

       
33
       
+
       
let () = validate_stdin ()

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0