commit 306f028495cec993b9cde1a35c4b3ca3a32942d2 · ryan.freumh.org/caledonia

+3 -1

bin/list_cmd.ml

···

       59
       59
        
           Query.query ~fs calendar_dir ?filter ~from ~to_ ?limit:count ()

     

       60
       60
        
         in

     

       61
       61
        
         if results = [] then print_endline "No events found."

     

       62
       62
       -
         else print_endline (Format.format_instances ~format ~tz results);

     

       62
       62
       +
         else

     

       63
       63
       +
           print_endline

     

       64
       64
       +
             (Format.format_instances ~fs ~calendar_dir ~format ~tz results);

     

       63
       65
        
         Ok ()

     

       64
       66
        
       

     

       65
       67
        
       let cmd ~fs calendar_dir =

+1 -1

bin/search_cmd.ml

···

       72
       72
        
           Query.query ~fs calendar_dir ~filter ~from ~to_ ?limit:count ()

     

       73
       73
        
         in

     

       74
       74
        
         if results = [] then print_endline "No events found."

     

       75
       75
       -
         else print_endline (Format.format_instances ~format results);

     

       75
       75
       +
         else print_endline (Format.format_instances ~fs ~calendar_dir ~format results);

     

       76
       76
        
         Ok ()

     

       77
       77
        
       

     

       78
       78
        
       let query_text_arg =

+1 -1

bin/show_cmd.ml

···

       6
       6
        
         let filter = Query.with_id event_id in

     

       7
       7
        
         let* results = Query.query_events ~fs calendar_dir ~filter () in

     

       8
       8
        
         if results = [] then print_endline "No events found."

     

       9
       9
       -
         else print_endline (Format.format_events ~format results);

     

       9
       9
       +
         else print_endline (Format.format_events ~fs ~calendar_dir ~format results);

     

       10
       10
        
         Ok ()

     

       11
       11
        
       

     

       12
       12
        
       let event_id_arg =

+2

lib/calendar_dir.ml

···

       255
       255
        
             | None -> [])

     

       256
       256
        
             calendar_dir.collections;

     

       257
       257
        
         Ok ()

     

       258
       258
       +
       

     

       259
       259
       +
       let get_path t = t.path

+2

lib/calendar_dir.mli

···

       51
       51
        
         t ->

     

       52
       52
        
         Event.t ->

     

       53
       53
        
         (unit, [> `Msg of string ]) result

     

       54
       54
       +
       

     

       55
       55
       +
       val get_path : t -> string

+42 -19

lib/format.ml

···

       124
       124
        
             recur_to_ics recur)

     

       125
       125
        
           l

     

       126
       126
        
       

     

       127
       127
       -
       let format_alt ~format ~start ~end_ ?tz event =

     

       127
       127
       +
       let format_alt ~fs ~calendar_dir ~format ~start ~end_ ?tz event =

     

       128
       128
        
         let open Event in

     

       129
       129
        
         match format with

     

       130
       130
        
         | `Text ->

     
···

       188
       188
        
               |> Option.value ~default:""

     

       189
       189
        
             in

     

       190
       190
        
             let summary_str = format_opt "Summary" Fun.id (get_summary event) in

     

       191
       191
       -
             Printf.sprintf "%s%s%s%s%s%s" summary_str start_str end_str location_str

     

       192
       192
       -
               description_str rrule_str

     

       191
       191
       +
             let file_str =

     

       192
       192
       +
               format_opt "File" Fun.id

     

       193
       193
       +
                 (Some

     

       194
       194
       +
                    (snd

     

       195
       195
       +
                       (get_file_path ~fs

     

       196
       196
       +
                          ~calendar_dir_path:(Calendar_dir.get_path calendar_dir)

     

       197
       197
       +
                          event)))

     

       198
       198
       +
             in

     

       199
       199
       +
             Printf.sprintf "%s%s%s%s%s%s%s" summary_str start_str end_str location_str

     

       200
       200
       +
               description_str rrule_str file_str

     

       193
       201
        
         | `Json ->

     

       194
       202
        
             let open Yojson.Safe in

     

       195
       203
        
             let json =

     
···

       309
       317
        
               (String.escaped id) (String.escaped summary) start_date start_time

     

       310
       318
        
               end_str location description calendar

     

       311
       319
        
       

     

       312
       312
       -
       let format_event ?(format = `Text) ?tz event =

     

       313
       313
       -
         format_alt ~format ~start:(Event.get_start event) ~end_:(Event.get_end event)

     

       314
       314
       -
           ?tz event

     

       320
       320
       +
       let format_event ~fs ~calendar_dir ?(format = `Text) ?tz event =

     

       321
       321
       +
         format_alt ~fs ~calendar_dir ~format ~start:(Event.get_start event)

     

       322
       322
       +
           ~end_:(Event.get_end event) ?tz event

     

       315
       323
        
       

     

       316
       316
       -
       let format_instance ?(format = `Text) ?tz instance =

     

       324
       324
       +
       let format_instance ~fs ~calendar_dir ?(format = `Text) ?tz instance =

     

       317
       325
        
         let open Recur in

     

       318
       318
       -
         format_alt ~format ~start:instance.start ~end_:instance.end_ ?tz

     

       319
       319
       -
           instance.event

     

       326
       326
       +
         format_alt ~fs ~calendar_dir ~format ~start:instance.start ~end_:instance.end_

     

       327
       327
       +
           ?tz instance.event

     

       320
       328
        
       

     

       321
       321
       -
       let format_events ?(format = `Text) ?tz events =

     

       329
       329
       +
       let format_events ~fs ~calendar_dir ?(format = `Text) ?tz events =

     

       322
       330
        
         match format with

     

       323
       331
        
         | `Json ->

     

       324
       332
        
             let json_events =

     

       325
       333
        
               List.map

     

       326
       326
       -
                 (fun e -> Yojson.Safe.from_string (format_event ~format:`Json ?tz e))

     

       334
       334
       +
                 (fun e ->

     

       335
       335
       +
                   Yojson.Safe.from_string

     

       336
       336
       +
                     (format_event ~fs ~calendar_dir ~format:`Json ?tz e))

     

       327
       337
        
                 events

     

       328
       338
        
             in

     

       329
       339
        
             Yojson.Safe.to_string (`List json_events)

     

       330
       340
        
         | `Csv ->

     

       331
       341
        
             "\"Summary\",\"Start\",\"End\",\"Location\",\"Calendar\"\n"

     

       332
       332
       -
             ^ String.concat "\n" (List.map (format_event ~format:`Csv ?tz) events)

     

       342
       342
       +
             ^ String.concat "\n"

     

       343
       343
       +
                 (List.map (format_event ~fs ~calendar_dir ~format:`Csv ?tz) events)

     

       333
       344
        
         | `Sexp ->

     

       334
       345
        
             "("

     

       335
       346
        
             ^ String.concat "\n "

     

       336
       336
       -
                 (List.map (fun e -> format_event ~format:`Sexp ?tz e) events)

     

       347
       347
       +
                 (List.map

     

       348
       348
       +
                    (fun e -> format_event ~fs ~calendar_dir ~format:`Sexp ?tz e)

     

       349
       349
       +
                    events)

     

       337
       350
        
             ^ ")"

     

       338
       351
        
         | _ ->

     

       339
       339
       -
             String.concat "\n" (List.map (fun e -> format_event ~format ?tz e) events)

     

       352
       352
       +
             String.concat "\n"

     

       353
       353
       +
               (List.map

     

       354
       354
       +
                  (fun e -> format_event ~fs ~calendar_dir ~format ?tz e)

     

       355
       355
       +
                  events)

     

       340
       356
        
       

     

       341
       341
       -
       let format_instances ?(format = `Text) ?tz instances =

     

       357
       357
       +
       let format_instances ~fs ~calendar_dir ?(format = `Text) ?tz instances =

     

       342
       358
        
         match format with

     

       343
       359
        
         | `Json ->

     

       344
       360
        
             let json_instances =

     

       345
       361
        
               List.map

     

       346
       362
        
                 (fun e ->

     

       347
       347
       -
                   Yojson.Safe.from_string (format_instance ~format:`Json ?tz e))

     

       363
       363
       +
                   Yojson.Safe.from_string

     

       364
       364
       +
                     (format_instance ~fs ~calendar_dir ~format:`Json ?tz e))

     

       348
       365
        
                 instances

     

       349
       366
        
             in

     

       350
       367
        
             Yojson.Safe.to_string (`List json_instances)

     

       351
       368
        
         | `Csv ->

     

       352
       369
        
             "\"Summary\",\"Start\",\"End\",\"Location\",\"Calendar\"\n"

     

       353
       370
        
             ^ String.concat "\n"

     

       354
       354
       -
                 (List.map (format_instance ~format:`Csv ?tz) instances)

     

       371
       371
       +
                 (List.map

     

       372
       372
       +
                    (format_instance ~fs ~calendar_dir ~format:`Csv ?tz)

     

       373
       373
       +
                    instances)

     

       355
       374
        
         | `Sexp ->

     

       356
       375
        
             "("

     

       357
       376
        
             ^ String.concat "\n "

     

       358
       358
       -
                 (List.map (fun e -> format_instance ~format:`Sexp ?tz e) instances)

     

       377
       377
       +
                 (List.map

     

       378
       378
       +
                    (fun e -> format_instance ~fs ~calendar_dir ~format:`Sexp ?tz e)

     

       379
       379
       +
                    instances)

     

       359
       380
        
             ^ ")"

     

       360
       381
        
         | _ ->

     

       361
       382
        
             String.concat "\n"

     

       362
       362
       -
               (List.map (fun e -> format_instance ~format ?tz e) instances)

     

       383
       383
       +
               (List.map

     

       384
       384
       +
                  (fun e -> format_instance ~fs ~calendar_dir ~format ?tz e)

     

       385
       385
       +
                  instances)

+24 -4

lib/format.mli

···

       5
       5
        
       

     

       6
       6
        
       (** Functions for formatting specific event types *)

     

       7
       7
        
       val format_event :

     

       8
       8
       -
         ?format:format -> ?tz:Timedesc.Time_zone.t -> Event.t -> string

     

       8
       8
       +
         fs:'a Eio.Path.t ->

     

       9
       9
       +
         calendar_dir:Calendar_dir.t ->

     

       10
       10
       +
         ?format:format ->

     

       11
       11
       +
         ?tz:Timedesc.Time_zone.t ->

     

       12
       12
       +
         Event.t ->

     

       13
       13
       +
         string

     

       9
       14
        
       (** Format a single event, optionally using the specified timezone *)

     

       10
       15
        
       

     

       11
       16
        
       val format_instance :

     

       12
       12
       -
         ?format:format -> ?tz:Timedesc.Time_zone.t -> Recur.instance -> string

     

       17
       17
       +
         fs:'a Eio.Path.t ->

     

       18
       18
       +
         calendar_dir:Calendar_dir.t ->

     

       19
       19
       +
         ?format:format ->

     

       20
       20
       +
         ?tz:Timedesc.Time_zone.t ->

     

       21
       21
       +
         Recur.instance ->

     

       22
       22
       +
         string

     

       13
       23
        
       (** Format a single event instance, optionally using the specified timezone *)

     

       14
       24
        
       

     

       15
       25
        
       val format_events :

     

       16
       16
       -
         ?format:format -> ?tz:Timedesc.Time_zone.t -> Event.t list -> string

     

       26
       26
       +
         fs:'a Eio.Path.t ->

     

       27
       27
       +
         calendar_dir:Calendar_dir.t ->

     

       28
       28
       +
         ?format:format ->

     

       29
       29
       +
         ?tz:Timedesc.Time_zone.t ->

     

       30
       30
       +
         Event.t list ->

     

       31
       31
       +
         string

     

       17
       32
        
       (** Format a list of events, optionally using the specified timezone *)

     

       18
       33
        
       

     

       19
       34
        
       val format_instances :

     

       20
       20
       -
         ?format:format -> ?tz:Timedesc.Time_zone.t -> Recur.instance list -> string

     

       35
       35
       +
         fs:'a Eio.Path.t ->

     

       36
       36
       +
         calendar_dir:Calendar_dir.t ->

     

       37
       37
       +
         ?format:format ->

     

       38
       38
       +
         ?tz:Timedesc.Time_zone.t ->

     

       39
       39
       +
         Recur.instance list ->

     

       40
       40
       +
         string

     

       21
       41
        
       (** Format a list of event instances, optionally using the specified timezone *)