commit bad3784a7cd834e5f5df494e8b312803901c5455 · ryan.freumh.org/caledonia

+3 -2

bin/add_cmd.ml

···

       21
       21
        
         in

     

       22
       22
        
         let collection = Collection.Col collection in

     

       23
       23
        
         let event =

     

       24
       24
       -
           Event.create ~summary ~start ?end_ ?location ?description ?recurrence

     

       25
       25
       -
             collection

     

       24
       24
       +
           Event.create ~fs

     

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

     

       26
       26
       +
             ~summary ~start ?end_ ?location ?description ?recurrence collection

     

       26
       27
        
         in

     

       27
       28
        
         let* _ = Calendar_dir.add_event ~fs calendar_dir event in

     

       28
       29
        
         Printf.printf "Event created with ID: %s\n" (Event.get_id event);

+1 -2

bin/list_cmd.ml

···

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

     

       61
       61
        
         in

     

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

     

       63
       63
       -
         else

     

       64
       64
       -
           print_endline (Format.format_events ~fs ~calendar_dir ~format ~tz results);

     

       63
       63
       +
         else print_endline (Format.format_events ~format ~tz results);

     

       65
       64
        
         Ok ()

     

       66
       65
        
       

     

       67
       66
        
       let cmd ~fs calendar_dir =

+1 -2

bin/search_cmd.ml

···

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

     

       77
       77
        
         in

     

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

     

       79
       79
       -
         else

     

       80
       80
       -
           print_endline (Format.format_events ~tz ~fs ~calendar_dir ~format results);

     

       79
       79
       +
         else print_endline (Format.format_events ~tz ~format results);

     

       81
       80
        
         Ok ()

     

       82
       81
        
       

     

       83
       82
        
       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_without_recurrence ~fs calendar_dir ~filter () in

     

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

     

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

     

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

     

       10
       10
        
         Ok ()

     

       11
       11
        
       

     

       12
       12
        
       let event_id_arg =

+11 -21

lib/calendar_dir.ml

···

       53
       53
        
             try

     

       54
       54
        
               let content = Eio.Path.load file in

     

       55
       55
        
               match parse content with

     

       56
       56
       -
               | Ok calendar ->

     

       57
       57
       -
                   Event.events_of_icalendar ~file_name collection calendar

     

       56
       56
       +
               | Ok calendar -> Event.events_of_icalendar ~file collection calendar

     

       58
       57
        
               | Error err ->

     

       59
       58
        
                   Printf.eprintf "Failed to parse %s: %s\n%!" file_path err;

     

       60
       59
        
                   []

     
···

       109
       108
        
       

     

       110
       109
        
       let add_event ~fs calendar_dir event =

     

       111
       110
        
         let collection = Event.get_collection event in

     

       112
       112
       -
         let file_path =

     

       113
       113
       -
           Event.get_file_path ~fs ~calendar_dir_path:calendar_dir.path event

     

       114
       114
       -
         in

     

       111
       111
       +
         let file = Event.get_file event in

     

       115
       112
        
         let collection_path = get_collection_path ~fs calendar_dir collection in

     

       116
       113
        
         let* () = ensure_dir collection_path in

     

       117
       114
        
         let calendar = Event.to_ical_calendar event in

     

       118
       115
        
         let content = Icalendar.to_ics ~cr:true calendar in

     

       119
       116
        
         let* _ =

     

       120
       117
        
           try

     

       121
       121
       -
             Eio.Path.save ~create:(`Or_truncate 0o644) file_path content;

     

       118
       118
       +
             Eio.Path.save ~create:(`Or_truncate 0o644) file content;

     

       122
       119
        
             Ok ()

     

       123
       120
        
           with Eio.Exn.Io _ as exn ->

     

       124
       121
        
             Error

     

       125
       122
        
               (`Msg

     

       126
       126
       -
                  (Fmt.str "Failed to write file %s: %a\n%!" (snd file_path) Eio.Exn.pp

     

       127
       127
       -
                     exn))

     

       123
       123
       +
                  (Fmt.str "Failed to write file %s: %a\n%!" (snd file) Eio.Exn.pp exn))

     

       128
       124
        
         in

     

       129
       125
        
         calendar_dir.collections <-

     

       130
       126
        
           CollectionMap.add collection

     
···

       142
       138
        
         let collection_path = get_collection_path ~fs calendar_dir collection in

     

       143
       139
        
         let* () = ensure_dir collection_path in

     

       144
       140
        
         let ical_event = Event.to_ical_event event in

     

       145
       145
       -
         let file_path =

     

       146
       146
       -
           Event.get_file_path ~fs ~calendar_dir_path:calendar_dir.path event

     

       147
       147
       -
         in

     

       141
       141
       +
         let file = Event.get_file event in

     

       148
       142
        
         let existing_props, existing_components = Event.to_ical_calendar event in

     

       149
       143
        
         let calendar =

     

       150
       144
        
           (* Replace the event with our updated version *)

     
···

       163
       157
        
         let content = Icalendar.to_ics ~cr:true calendar in

     

       164
       158
        
         let* _ =

     

       165
       159
        
           try

     

       166
       166
       -
             Eio.Path.save ~create:(`Or_truncate 0o644) file_path content;

     

       160
       160
       +
             Eio.Path.save ~create:(`Or_truncate 0o644) file content;

     

       167
       161
        
             Ok ()

     

       168
       162
        
           with Eio.Exn.Io _ as exn ->

     

       169
       163
        
             Error

     

       170
       164
        
               (`Msg

     

       171
       171
       -
                  (Fmt.str "Failed to write file %s: %a\n%!" (snd file_path) Eio.Exn.pp

     

       172
       172
       -
                     exn))

     

       165
       165
       +
                  (Fmt.str "Failed to write file %s: %a\n%!" (snd file) Eio.Exn.pp exn))

     

       173
       166
        
         in

     

       174
       167
        
         calendar_dir.collections <-

     

       175
       168
        
           CollectionMap.add collection

     
···

       187
       180
        
         let event_id = Event.get_id event in

     

       188
       181
        
         let collection_path = get_collection_path ~fs calendar_dir collection in

     

       189
       182
        
         let* () = ensure_dir collection_path in

     

       190
       190
       -
         let file_path =

     

       191
       191
       -
           Event.get_file_path ~fs ~calendar_dir_path:calendar_dir.path event

     

       192
       192
       -
         in

     

       183
       183
       +
         let file = Event.get_file event in

     

       193
       184
        
         let existing_props, existing_components = Event.to_ical_calendar event in

     

       194
       185
        
         let other_events = ref false in

     

       195
       186
        
         let calendar =

     
···

       213
       204
        
         let* _ =

     

       214
       205
        
           try

     

       215
       206
        
             (match !other_events with

     

       216
       216
       -
             | true -> Eio.Path.save ~create:(`Or_truncate 0o644) file_path content

     

       217
       217
       -
             | false -> Eio.Path.unlink file_path);

     

       207
       207
       +
             | true -> Eio.Path.save ~create:(`Or_truncate 0o644) file content

     

       208
       208
       +
             | false -> Eio.Path.unlink file);

     

       218
       209
        
             Ok ()

     

       219
       210
        
           with Eio.Exn.Io _ as exn ->

     

       220
       211
        
             Error

     

       221
       212
        
               (`Msg

     

       222
       222
       -
                  (Fmt.str "Failed to write file %s: %a\n%!" (snd file_path) Eio.Exn.pp

     

       223
       223
       -
                     exn))

     

       213
       213
       +
                  (Fmt.str "Failed to write file %s: %a\n%!" (snd file) Eio.Exn.pp exn))

     

       224
       214
        
         in

     

       225
       215
        
         calendar_dir.collections <-

     

       226
       216
        
           CollectionMap.add collection

+7 -9

lib/calendar_dir.mli

···

       6
       6
        
           containing .ics files *)

     

       7
       7
        
       

     

       8
       8
        
       val create :

     

       9
       9
       -
         fs:[> Eio.Fs.dir_ty ] Eio.Path.t -> string -> (t, [> `Msg of string ]) result

     

       9
       9
       +
         fs:Eio.Fs.dir_ty Eio.Path.t -> string -> (t, [> `Msg of string ]) result

     

       10
       10
        
       (** Create a calendar_dir from a directory path. Returns Ok with the

     

       11
       11
        
           calendar_dir if successful, or Error with a message if the directory cannot

     

       12
       12
        
           be created or accessed. *)

     

       13
       13
        
       

     

       14
       14
        
       val list_collections :

     

       15
       15
       -
         fs:[> Eio.Fs.dir_ty ] Eio.Path.t ->

     

       15
       15
       +
         fs:Eio.Fs.dir_ty Eio.Path.t ->

     

       16
       16
        
         t ->

     

       17
       17
        
         (Collection.t list, [> `Msg of string ]) result

     

       18
       18
        
       (** List available Collection.ts in the calendar_dir. Returns Ok with the list

     
···

       20
       20
        
           directory cannot be read. *)

     

       21
       21
        
       

     

       22
       22
        
       val get_collection :

     

       23
       23
       -
         fs:[> Eio.Fs.dir_ty ] Eio.Path.t ->

     

       23
       23
       +
         fs:Eio.Fs.dir_ty Eio.Path.t ->

     

       24
       24
        
         t ->

     

       25
       25
        
         Collection.t ->

     

       26
       26
        
         (Event.t list, [> `Msg of string | `Not_found ]) result

     
···

       28
       28
        
           the cache, it will be loaded from disk. *)

     

       29
       29
        
       

     

       30
       30
        
       val get_events :

     

       31
       31
       -
         fs:[> Eio.Fs.dir_ty ] Eio.Path.t ->

     

       32
       32
       -
         t ->

     

       33
       33
       -
         (Event.t list, [> `Msg of string ]) result

     

       31
       31
       +
         fs:Eio.Fs.dir_ty Eio.Path.t -> t -> (Event.t list, [> `Msg of string ]) result

     

       34
       32
        
       (** Get all events in all collections. This will load any Collection.ts that

     

       35
       33
        
           haven't been loaded yet. *)

     

       36
       34
        
       

     

       37
       35
        
       val add_event :

     

       38
       38
       -
         fs:[> Eio.Fs.dir_ty ] Eio.Path.t ->

     

       36
       36
       +
         fs:Eio.Fs.dir_ty Eio.Path.t ->

     

       39
       37
        
         t ->

     

       40
       38
        
         Event.t ->

     

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

     

       42
       40
        
       

     

       43
       41
        
       val edit_event :

     

       44
       44
       -
         fs:[> Eio.Fs.dir_ty ] Eio.Path.t ->

     

       42
       42
       +
         fs:Eio.Fs.dir_ty Eio.Path.t ->

     

       45
       43
        
         t ->

     

       46
       44
        
         Event.t ->

     

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

     

       48
       46
        
       

     

       49
       47
        
       val delete_event :

     

       50
       50
       -
         fs:[> Eio.Fs.dir_ty ] Eio.Path.t ->

     

       48
       48
       +
         fs:Eio.Fs.dir_ty Eio.Path.t ->

     

       51
       49
        
         t ->

     

       52
       50
        
         Event.t ->

     

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

+17 -16

lib/event.ml

···

       4
       4
        
       

     

       5
       5
        
       type t = {

     

       6
       6
        
         collection : Collection.t;

     

       7
       7
       -
         file_name : string;

     

       7
       7
       +
         file : Eio.Fs.dir_ty Eio.Path.t;

     

       8
       8
        
         event : event;

     

       9
       9
        
         calendar : calendar;

     

       10
       10
        
       }

     
···

       17
       17
        
       

     

       18
       18
        
       let default_prodid = `Prodid (Params.empty, "-//Freumh//Caledonia//EN")

     

       19
       19
        
       

     

       20
       20
       -
       let create ~summary ~start ?end_ ?location ?description ?recurrence collection =

     

       20
       20
       +
       let create ~(fs : Eio.Fs.dir_ty Eio.Path.t) ~calendar_dir_path ~summary ~start

     

       21
       21
       +
           ?end_ ?location ?description ?recurrence collection =

     

       21
       22
        
         let uuid = generate_uuid () in

     

       22
       23
        
         let uid = (Params.empty, uuid) in

     

       23
       24
        
         let file_name = uuid ^ ".ics" in

     

       25
       25
       +
         let file =

     

       26
       26
       +
           Eio.Path.(

     

       27
       27
       +
             fs / calendar_dir_path

     

       28
       28
       +
             / (match collection with Collection.Col s -> s)

     

       29
       29
       +
             / file_name)

     

       30
       30
       +
         in

     

       24
       31
        
         let dtstart = (Params.empty, start) in

     

       25
       32
        
         let dtend_or_duration = end_ in

     

       26
       33
        
         let rrule = Option.map (fun r -> (Params.empty, r)) recurrence in

     
···

       52
       59
        
           let components = [ `Event event ] in

     

       53
       60
        
           (props, components)

     

       54
       61
        
         in

     

       55
       55
       -
         { collection; file_name; event; calendar }

     

       62
       62
       +
         { collection; file; event; calendar }

     

       56
       63
        
       

     

       57
       64
        
       let edit ?summary ?start ?end_ ?location ?description ?recurrence t =

     

       58
       65
        
         let now = Ptime_clock.now () in

     
···

       106
       113
        
           }

     

       107
       114
        
         in

     

       108
       115
        
         let collection = t.collection in

     

       109
       109
       -
         let file_name = t.file_name in

     

       116
       116
       +
         let file = t.file in

     

       110
       117
        
         let calendar = t.calendar in

     

       111
       111
       -
         { collection; file_name; event; calendar }

     

       118
       118
       +
         { collection; file; event; calendar }

     

       112
       119
        
       

     

       113
       113
       -
       let events_of_icalendar collection ~file_name calendar =

     

       120
       120
       +
       let events_of_icalendar collection ~file calendar =

     

       114
       121
        
         List.filter_map

     

       115
       122
        
           (function

     

       116
       116
       -
             | `Event event -> Some { collection; file_name; event; calendar }

     

       117
       117
       -
             | _ -> None)

     

       123
       123
       +
             | `Event event -> Some { collection; file; event; calendar } | _ -> None)

     

       118
       124
        
           (snd calendar)

     

       119
       125
        
       

     

       120
       126
        
       let to_ical_event t = t.event

     
···

       193
       199
        
       

     

       194
       200
        
       let get_recurrence t = Option.map (fun r -> snd r) t.event.rrule

     

       195
       201
        
       let get_collection t = t.collection

     

       196
       196
       -
       

     

       197
       197
       -
       let get_file_path ~fs ~calendar_dir_path t =

     

       198
       198
       -
         Eio.Path.(

     

       199
       199
       -
           fs / calendar_dir_path

     

       200
       200
       -
           / (match t.collection with Col s -> s)

     

       201
       201
       -
           / t.file_name)

     

       202
       202
       +
       let get_file t = t.file

     

       202
       203
        
       

     

       203
       204
        
       let get_recurrence_ids t =

     

       204
       205
        
         let _, recurrence_ids =

     
···

       251
       252
        
       

     

       252
       253
        
       let clone_with_event t event =

     

       253
       254
        
         let collection = t.collection in

     

       254
       254
       -
         let file_name = t.file_name in

     

       255
       255
       +
         let file = t.file in

     

       255
       256
        
         let calendar = t.calendar in

     

       256
       256
       -
         { collection; file_name; event; calendar }

     

       257
       257
       +
         { collection; file; event; calendar }

     

       257
       258
        
       

     

       258
       259
        
       let expand_recurrences ~from ~to_ event =

     

       259
       260
        
         let rule = get_recurrence event in

+4 -5

lib/event.mli

···

       9
       9
        
       type date_error = [ `Msg of string ]

     

       10
       10
        
       

     

       11
       11
        
       val create :

     

       12
       12
       +
         fs:Eio.Fs.dir_ty Eio.Path.t ->

     

       13
       13
       +
         calendar_dir_path:string ->

     

       12
       14
        
         summary:string ->

     

       13
       15
        
         start:Icalendar.date_or_datetime ->

     

       14
       16
        
         ?end_:

     
···

       41
       43
        
       (** Edit an existing event. *)

     

       42
       44
        
       

     

       43
       45
        
       val events_of_icalendar :

     

       44
       44
       -
         Collection.t -> file_name:string -> Icalendar.calendar -> t list

     

       46
       46
       +
         Collection.t -> file:Eio.Fs.dir_ty Eio.Path.t -> Icalendar.calendar -> t list

     

       45
       47
        
       

     

       46
       48
        
       val to_ical_event : t -> Icalendar.event

     

       47
       49
        
       val to_ical_calendar : t -> Icalendar.calendar

     
···

       69
       71
        
       val get_description : t -> string option

     

       70
       72
        
       val get_recurrence : t -> Icalendar.recurrence option

     

       71
       73
        
       val get_collection : t -> Collection.t

     

       72
       72
       -
       

     

       73
       73
       -
       val get_file_path :

     

       74
       74
       -
         fs:'a Eio.Path.t -> calendar_dir_path:string -> t -> 'a Eio.Path.t

     

       75
       75
       -
       

     

       74
       74
       +
       val get_file : t -> Eio.Fs.dir_ty Eio.Path.t

     

       76
       75
        
       val get_recurrence_ids : t -> Icalendar.event list

     

       77
       76
        
       

     

       78
       77
        
       type comparator = t -> t -> int

+7 -22

lib/format.ml

···

       124
       124
        
             recur_to_ics recur)

     

       125
       125
        
           l

     

       126
       126
        
       

     

       127
       127
       -
       let format_event ~fs ~calendar_dir ?(format = `Text) ?tz event =

     

       127
       127
       +
       let format_event ?(format = `Text) ?tz event =

     

       128
       128
        
         let open Event in

     

       129
       129
        
         let start = get_start event in

     

       130
       130
        
         let end_ = Event.get_end event in

     
···

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

     

       191
       191
        
             in

     

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

     

       193
       193
       -
             let file_str =

     

       194
       194
       -
               format_opt "File" Fun.id

     

       195
       195
       -
                 (Some

     

       196
       196
       -
                    (snd

     

       197
       197
       -
                       (get_file_path ~fs

     

       198
       198
       -
                          ~calendar_dir_path:(Calendar_dir.get_path calendar_dir)

     

       199
       199
       -
                          event)))

     

       200
       200
       -
             in

     

       193
       193
       +
             let file_str = format_opt "File" Fun.id (Some (snd (get_file event))) in

     

       201
       194
        
             Printf.sprintf "%s%s%s%s%s%s%s" summary_str start_str end_str location_str

     

       202
       195
        
               description_str rrule_str file_str

     

       203
       196
        
         | `Json ->

     
···

       318
       311
        
               (String.escaped id) (String.escaped summary) start_date start_time

     

       319
       312
        
               end_str location description calendar

     

       320
       313
        
       

     

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

     

       314
       314
       +
       let format_events ?(format = `Text) ?tz events =

     

       322
       315
        
         match format with

     

       323
       316
        
         | `Json ->

     

       324
       317
        
             let json_events =

     

       325
       318
        
               List.map

     

       326
       326
       -
                 (fun e ->

     

       327
       327
       -
                   Yojson.Safe.from_string

     

       328
       328
       -
                     (format_event ~fs ~calendar_dir ~format:`Json ?tz e))

     

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

     

       329
       320
        
                 events

     

       330
       321
        
             in

     

       331
       322
        
             Yojson.Safe.to_string (`List json_events)

     

       332
       323
        
         | `Csv ->

     

       333
       324
        
             "\"Summary\",\"Start\",\"End\",\"Location\",\"Calendar\"\n"

     

       334
       334
       -
             ^ String.concat "\n"

     

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

     

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

     

       336
       326
        
         | `Sexp ->

     

       337
       327
        
             "("

     

       338
       328
        
             ^ String.concat "\n "

     

       339
       339
       -
                 (List.map

     

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

     

       341
       341
       -
                    events)

     

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

     

       342
       330
        
             ^ ")"

     

       343
       331
        
         | _ ->

     

       344
       344
       -
             String.concat "\n"

     

       345
       345
       -
               (List.map

     

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

     

       347
       347
       -
                  events)

     

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

+2 -12

lib/format.mli

···

       5
       5
        
       

     

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

     

       7
       7
        
       val format_event :

     

       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

     

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

     

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

     

       15
       10
        
       

     

       16
       11
        
       val format_events :

     

       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
       -
         Event.t list ->

     

       22
       22
       -
         string

     

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

     

       23
       13
        
       (** Format a list of events, optionally using the specified timezone *)

+2 -2

lib/query.mli

···

       14
       14
        
       val not_filter : filter -> filter

     

       15
       15
        
       

     

       16
       16
        
       val query_without_recurrence :

     

       17
       17
       -
         fs:[> Eio.Fs.dir_ty ] Eio.Path.t ->

     

       17
       17
       +
         fs:Eio.Fs.dir_ty Eio.Path.t ->

     

       18
       18
        
         Calendar_dir.t ->

     

       19
       19
        
         ?filter:filter ->

     

       20
       20
        
         ?comparator:Event.comparator ->

     
···

       25
       25
        
           of events, or Error with a message. *)

     

       26
       26
        
       

     

       27
       27
        
       val query :

     

       28
       28
       -
         fs:[> Eio.Fs.dir_ty ] Eio.Path.t ->

     

       28
       28
       +
         fs:Eio.Fs.dir_ty Eio.Path.t ->

     

       29
       29
        
         Calendar_dir.t ->

     

       30
       30
        
         ?filter:filter ->

     

       31
       31
        
         from:Ptime.t option ->

+30 -20

test/test_query.ml

···

       134
       134
        
         | Error _ -> Alcotest.fail "Error querying events");

     

       135
       135
        
         ()

     

       136
       136
        
       

     

       137
       137
       -
       let test_events =

     

       137
       137
       +
       let test_events ~fs =

     

       138
       138
        
         (* Create a test event with specific text in all fields *)

     

       139
       139
        
         let create_test_event ~collection ~summary ~description ~location ~start =

     

       140
       140
       -
           Event.create ~summary ~start

     

       140
       140
       +
           Event.create ~fs ~calendar_dir_path ~summary ~start

     

       141
       141
        
             ?description:(if description = "" then None else Some description)

     

       142
       142
        
             ?location:(if location = "" then None else Some location)

     

       143
       143
        
             (Collection.Col collection)

     
···

       171
       171
        
           (fun e -> String.equal (Option.get @@ Event.get_summary e) summary)

     

       172
       172
        
           events

     

       173
       173
        
       

     

       174
       174
       -
       let test_case_insensitive_search () =

     

       174
       174
       +
       let test_case_insensitive_search ~fs () =

     

       175
       175
        
         (* Test lowercase query for an uppercase word *)

     

       176
       176
        
         let lowercase_filter = Query.summary_contains "important" in

     

       177
       177
        
         let matches =

     

       178
       178
       -
           List.filter (fun e -> Query.matches_filter e lowercase_filter) test_events

     

       178
       178
       +
           List.filter

     

       179
       179
       +
             (fun e -> Query.matches_filter e lowercase_filter)

     

       180
       180
       +
             (test_events ~fs)

     

       179
       181
        
         in

     

       180
       182
        
         Alcotest.(check bool)

     

       181
       183
        
           "Lowercase query should match uppercase text in summary" true

     
···

       183
       185
        
         (* Test uppercase query for a lowercase word *)

     

       184
       186
        
         let uppercase_filter = Query.description_contains "WEEKLY" in

     

       185
       187
        
         let matches =

     

       186
       186
       -
           List.filter (fun e -> Query.matches_filter e uppercase_filter) test_events

     

       188
       188
       +
           List.filter

     

       189
       189
       +
             (fun e -> Query.matches_filter e uppercase_filter)

     

       190
       190
       +
             (test_events ~fs)

     

       187
       191
        
         in

     

       188
       192
        
         Alcotest.(check bool)

     

       189
       193
        
           "Uppercase query should match lowercase text in description" true

     

       190
       194
        
           (contains_summary matches "Project Meeting")

     

       191
       195
        
       

     

       192
       192
       -
       let test_partial_word_matching () =

     

       196
       196
       +
       let test_partial_word_matching ~fs () =

     

       193
       197
        
         (* Test searching for part of a word *)

     

       194
       198
        
         let partial_filter = Query.summary_contains "Conf" in

     

       195
       199
        
         (* Should match "Conference" *)

     

       196
       200
        
         let matches =

     

       197
       197
       -
           List.filter (fun e -> Query.matches_filter e partial_filter) test_events

     

       201
       201
       +
           List.filter

     

       202
       202
       +
             (fun e -> Query.matches_filter e partial_filter)

     

       203
       203
       +
             (test_events ~fs)

     

       198
       204
        
         in

     

       199
       205
        
         Alcotest.(check bool)

     

       200
       206
        
           "Partial query should match full word in summary" true

     
···

       203
       209
        
         let partial_filter = Query.description_contains "nation" in

     

       204
       210
        
         (* Should match "International" *)

     

       205
       211
        
         let matches =

     

       206
       206
       -
           List.filter (fun e -> Query.matches_filter e partial_filter) test_events

     

       212
       212
       +
           List.filter

     

       213
       213
       +
             (fun e -> Query.matches_filter e partial_filter)

     

       214
       214
       +
             (test_events ~fs)

     

       207
       215
        
         in

     

       208
       216
        
         Alcotest.(check bool)

     

       209
       217
        
           "Partial query should match within word in description" true

     
···

       213
       221
        
           "Partial query should match within word in description" true

     

       214
       222
        
           (contains_summary matches "Conference Call")

     

       215
       223
        
       

     

       216
       216
       -
       let test_boolean_logic () =

     

       224
       224
       +
       let test_boolean_logic ~fs () =

     

       217
       225
        
         (* Test AND filter *)

     

       218
       226
        
         let and_filter =

     

       219
       227
        
           Query.and_filter

     

       220
       228
        
             [ Query.summary_contains "Meeting"; Query.description_contains "project" ]

     

       221
       229
        
         in

     

       222
       230
        
         let matches =

     

       223
       223
       -
           List.filter (fun e -> Query.matches_filter e and_filter) test_events

     

       231
       231
       +
           List.filter (fun e -> Query.matches_filter e and_filter) (test_events ~fs)

     

       224
       232
        
         in

     

       225
       233
        
         Alcotest.(check int)

     

       226
       234
        
           "AND filter should match events with both terms" 2

     
···

       232
       240
        
             [ Query.summary_contains "Workshop"; Query.summary_contains "Conference" ]

     

       233
       241
        
         in

     

       234
       242
        
         let matches =

     

       235
       235
       -
           List.filter (fun e -> Query.matches_filter e or_filter) test_events

     

       243
       243
       +
           List.filter (fun e -> Query.matches_filter e or_filter) (test_events ~fs)

     

       236
       244
        
         in

     

       237
       245
        
         Alcotest.(check int)

     

       238
       246
        
           "OR filter should match events with either term"

     
···

       242
       250
        
         (* Test NOT filter *)

     

       243
       251
        
         let not_filter = Query.not_filter (Query.summary_contains "Meeting") in

     

       244
       252
        
         let matches =

     

       245
       245
       -
           List.filter (fun e -> Query.matches_filter e not_filter) test_events

     

       253
       253
       +
           List.filter (fun e -> Query.matches_filter e not_filter) (test_events ~fs)

     

       246
       254
        
         in

     

       247
       255
        
         Alcotest.(check int)

     

       248
       256
        
           "NOT filter should match events without the term"

     
···

       265
       273
        
             ]

     

       266
       274
        
         in

     

       267
       275
        
         let matches =

     

       268
       268
       -
           List.filter (fun e -> Query.matches_filter e complex_filter) test_events

     

       276
       276
       +
           List.filter

     

       277
       277
       +
             (fun e -> Query.matches_filter e complex_filter)

     

       278
       278
       +
             (test_events ~fs)

     

       269
       279
        
         in

     

       270
       280
        
         Alcotest.(check int)

     

       271
       281
        
           "Complex filter should match correctly"

     

       272
       282
        
           3 (* Three events should match the complex criteria *)

     

       273
       283
        
           (List.length matches)

     

       274
       284
        
       

     

       275
       275
       -
       let test_cross_field_search () =

     

       285
       285
       +
       let test_cross_field_search ~fs () =

     

       276
       286
        
         (* Search for a term that appears in multiple fields across different events *)

     

       277
       287
        
         let term_filter =

     

       278
       288
        
           Query.or_filter

     
···

       283
       293
        
             ]

     

       284
       294
        
         in

     

       285
       295
        
         let matches =

     

       286
       286
       -
           List.filter (fun e -> Query.matches_filter e term_filter) test_events

     

       296
       296
       +
           List.filter (fun e -> Query.matches_filter e term_filter) (test_events ~fs)

     

       287
       297
        
         in

     

       288
       298
        
         Alcotest.(check int)

     

       289
       299
        
           "Cross-field search should find all occurrences"

     
···

       299
       309
        
             ]

     

       300
       310
        
         in

     

       301
       311
        
         let matches =

     

       302
       302
       -
           List.filter (fun e -> Query.matches_filter e term_filter) test_events

     

       312
       312
       +
           List.filter (fun e -> Query.matches_filter e term_filter) (test_events ~fs)

     

       303
       313
        
         in

     

       304
       314
        
         Alcotest.(check int)

     

       305
       315
        
           "Cross-field search should find all occurrences of 'conference'"

     
···

       312
       322
        
           ("recurrence expansion", `Quick, test_recurrence_expansion ~fs);

     

       313
       323
        
           ("text search", `Quick, test_text_search ~fs);

     

       314
       324
        
           ("calendar filter", `Quick, test_calendar_filter ~fs);

     

       315
       315
       -
           ("case insensitive search", `Quick, test_case_insensitive_search);

     

       316
       316
       -
           ("partial word matching", `Quick, test_partial_word_matching);

     

       317
       317
       -
           ("boolean logic filters", `Quick, test_boolean_logic);

     

       318
       318
       -
           ("cross-field searching", `Quick, test_cross_field_search);

     

       325
       325
       +
           ("case insensitive search", `Quick, test_case_insensitive_search ~fs);

     

       326
       326
       +
           ("partial word matching", `Quick, test_partial_word_matching ~fs);

     

       327
       327
       +
           ("boolean logic filters", `Quick, test_boolean_logic ~fs);

     

       328
       328
       +
           ("cross-field searching", `Quick, test_cross_field_search ~fs);

     

       319
       329
        
         ]

     

       320
       330
        
       

     

       321
       331
        
       let () =