commit 5b56468e5767969a396b9087e848f4e0f7cbfb06 · ryan.freumh.org/caledonia

+15 -7

bin/search_cmd.ml

···

       3
       3
        
       open Query_args

     

       4
       4
        
       

     

       5
       5
        
       let run ?from_str ?to_str ?calendar ?count ?query_text ~summary ~description

     

       6
       6
       -
           ~location ~format ~today ~tomorrow ~week ~month ~recurring ~non_recurring

     

       7
       7
       -
           ?timezone ~sort ~fs calendar_dir =

     

       6
       6
       +
           ~location ~id ~format ~today ~tomorrow ~week ~month ~recurring

     

       7
       7
       +
           ~non_recurring ?timezone ~sort ~fs calendar_dir =

     

       8
       8
        
         let ( let* ) = Result.bind in

     

       9
       9
        
         let filters = ref [] in

     

       10
       10
        
         let tz = Query_args.parse_timezone ~timezone in

     
···

       67
       67
        
         | None -> ());

     

       68
       68
        
         if recurring then filters := Query.recurring_only () :: !filters;

     

       69
       69
        
         if non_recurring then filters := Query.non_recurring_only () :: !filters;

     

       70
       70
       +
         (match id with

     

       71
       71
       +
         | Some id -> filters := Query.with_id id :: !filters

     

       72
       72
       +
         | None -> ());

     

       70
       73
        
         let filter = Query.and_filter !filters in

     

       71
       74
        
         let comparator = Query_args.create_event_comparator sort in

     

       72
       75
        
         let* results =

     
···

       100
       103
        
       let non_recurring_arg =

     

       101
       104
        
         let doc = "Search for non-recurring events only" in

     

       102
       105
        
         Arg.(value & flag & info [ "non-recurring"; "R" ] ~doc)

     

       106
       106
       +
       

     

       107
       107
       +
       let id_arg =

     

       108
       108
       +
         let doc = "Search for an event with a specific ID" in

     

       109
       109
       +
         Arg.(value & opt (some string) None & info [ "id"; "i" ] ~docv:"ID" ~doc)

     

       103
       110
        
       

     

       104
       111
        
       let cmd ~fs calendar_dir =

     

       105
       112
        
         let run query_text from_str to_str calendar count format summary description

     

       106
       106
       -
             location today tomorrow week month recurring non_recurring timezone sort =

     

       113
       113
       +
             location id today tomorrow week month recurring non_recurring timezone

     

       114
       114
       +
             sort =

     

       107
       115
        
           match

     

       108
       116
        
             run ?from_str ?to_str ?calendar ?count ?query_text ~summary ~description

     

       109
       109
       -
               ~location ~format ~today ~tomorrow ~week ~month ~recurring

     

       117
       117
       +
               ~location ~id ~format ~today ~tomorrow ~week ~month ~recurring

     

       110
       118
        
               ~non_recurring ?timezone ~sort ~fs calendar_dir

     

       111
       119
        
           with

     

       112
       120
        
           | Error (`Msg msg) ->

     
···

       117
       125
        
         let term =

     

       118
       126
        
           Term.(

     

       119
       127
        
             const run $ query_text_arg $ from_arg $ to_arg $ calendar_arg $ count_arg

     

       120
       120
       -
             $ format_arg $ summary_arg $ description_arg $ location_arg $ today_arg

     

       121
       121
       -
             $ tomorrow_arg $ week_arg $ month_arg $ recurring_arg $ non_recurring_arg

     

       122
       122
       -
             $ timezone_arg $ sort_arg)

     

       128
       128
       +
             $ format_arg $ summary_arg $ description_arg $ location_arg $ id_arg

     

       129
       129
       +
             $ today_arg $ tomorrow_arg $ week_arg $ month_arg $ recurring_arg

     

       130
       130
       +
             $ non_recurring_arg $ timezone_arg $ sort_arg)

     

       123
       131
        
         in

     

       124
       132
        
         let doc = "Search calendar events for specific text" in

     

       125
       133
        
         let man =

+1 -1

lib/calendar_dir.ml

···

       83
       83
        
                   (`Msg

     

       84
       84
        
                      (Printf.sprintf "Exception processing directory %s: %s"

     

       85
       85
        
                         (snd collection_path) (Printexc.to_string e))))

     

       86
       86
       -
         

     

       86
       86
       +
       

     

       87
       87
        
       let ( let* ) = Result.bind

     

       88
       88
        
       

     

       89
       89
        
       let get_events ~fs calendar_dir =

+2 -2

lib/calendar_dir.mli

···

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

     

       32
       32
        
         t ->

     

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

     

       34
       34
       -
       (** Get all events in all collections. This will load any

     

       35
       35
       -
           Collection.ts that haven't been loaded yet. *)

     

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

     

       35
       35
       +
           haven't been loaded yet. *)

     

       36
       36
        
       

     

       37
       37
        
       val add_event :

     

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

+6 -6

lib/event.ml

···

       130
       130
        
         | s :: _ -> Some s

     

       131
       131
        
         | _ -> None

     

       132
       132
        
       

     

       133
       133
       -
       let get_ical_start event =

     

       134
       134
       -
         Date.ptime_of_ical (snd event.dtstart)

     

       135
       135
       -
       

     

       133
       133
       +
       let get_ical_start event = Date.ptime_of_ical (snd event.dtstart)

     

       136
       134
        
       let get_start t = get_ical_start t.event

     

       137
       135
        
       

     

       138
       136
        
       let get_ical_end event =

     
···

       279
       277
        
               | None -> List.rev acc

     

       280
       278
        
               | Some recur ->

     

       281
       279
        
                   let start = get_ical_start recur in

     

       282
       282
       -
                   let end_ = match get_ical_end recur with None -> start | Some e -> e in

     

       280
       280
       +
                   let end_ =

     

       281
       281
       +
                     match get_ical_end recur with None -> start | Some e -> e

     

       282
       282
       +
                   in

     

       283
       283
        
                   (* if start >= to then we're outside our (exclusive) date range and we terminate *)

     

       284
       284
        
                   if Ptime.compare start to_ >= 0 then List.rev acc

     

       285
       285
       -
                   (* if end > from then, *)

     

       285
       285
       +
                     (* if end > from then, *)

     

       286
       286
        
                   else if

     

       287
       287
        
                     match from with

     

       288
       288
        
                     | Some f -> Ptime.compare end_ f > 0

     
···

       290
       290
        
                   (* we include the event *)

     

       291
       291
        
                   then collect generator (clone_with_event event recur :: acc)

     

       292
       292
        
                   (* otherwise we iterate till the event is in range *)

     

       293
       293
       -
                   else collect generator acc

     

       293
       293
       +
                     else collect generator acc

     

       294
       294
        
             in

     

       295
       295
        
             let generator =

     

       296
       296
        
               let ical_event = to_ical_event event in

+2 -5

test/test_calendar_dir.ml

···

       48
       48
        
         in

     

       49
       49
        
         match Calendar_dir.get_events ~fs calendar_dir with

     

       50
       50
        
         | Ok events ->

     

       51
       51
       -
             Alcotest.(check int)

     

       52
       52
       -
               "Should find two events" 32 (List.length events);

     

       51
       51
       +
             Alcotest.(check int) "Should find two events" 32 (List.length events);

     

       53
       52
        
             ()

     

       54
       53
        
         | Error e ->

     

       55
       55
       -
             let msg =

     

       56
       56
       -
               match e with `Msg m -> m

     

       57
       57
       -
             in

     

       54
       54
       +
             let msg = match e with `Msg m -> m in

     

       58
       55
        
             Alcotest.fail ("Error getting collections: " ^ msg)

     

       59
       56
        
       

     

       60
       57
        
       let calendar_tests fs =