commit 9e5d6377db4cb636c6f729f240285cad9c6ebff3 · ryan.freumh.org/caledonia

+12 -8

bin/add_cmd.ml

···

       59
       59
        
           @ date_format_manpage_entries

     

       60
       60
        
           @ [

     

       61
       61
        
               `S Manpage.s_examples;

     

       62
       62
       -
               `I ("Add a event for today:", "caled add \"Meeting\" -d today -t 14:00");

     

       62
       62
       +
               `I

     

       63
       63
       +
                 ( "Add a event for today:",

     

       64
       64
       +
                   "caled add \"Meeting\" --date today --time 14:00" );

     

       63
       65
        
               `I

     

       64
       66
        
                 ( "Add an event with a specific date and time:",

     

       65
       65
       -
                   "caled add \"Dentist Appointment\" -d 2025-04-15 -t 10:30" );

     

       67
       67
       +
                   "caled add \"Dentist Appointment\" --date 2025-04-15 --time 10:30"

     

       68
       68
       +
                 );

     

       66
       69
        
               `I

     

       67
       70
        
                 ( "Add an event with an end time:",

     

       68
       68
       -
                   "caled add \"Conference\" -d 2025-05-20 -t 09:00 -e 2025-05-22 -T \

     

       69
       69
       -
                    17:00" );

     

       71
       71
       +
                   "caled add \"Conference\" --date 2025-05-20 --time 09:00 \

     

       72
       72
       +
                    --end-date 2025-05-22 --end-time 17:00" );

     

       70
       73
        
               `I

     

       71
       74
        
                 ( "Add an event with location and description:",

     

       72
       72
       -
                   "caled add \"Lunch with Bob\" -d 2025-04-02 -t 12:30 -l \"Pasta \

     

       73
       73
       -
                    Restaurant\" -D \"Discuss project plans\"" );

     

       75
       75
       +
                   "caled add \"Lunch with Bob\" --date 2025-04-02 --time 12:30 \

     

       76
       76
       +
                    --location \"Pasta Restaurant\" --description \"Discuss project \

     

       77
       77
       +
                    plans\"" );

     

       74
       78
        
               `I

     

       75
       79
        
                 ( "Add an event to a specific calendar:",

     

       76
       76
       -
                   "caled add \"Work Meeting\" -d 2025-04-03 -t 15:00 --calendar work"

     

       77
       77
       -
                 );

     

       80
       80
       +
                   "caled add \"Work Meeting\" --date 2025-04-03 --time 15:00 \

     

       81
       81
       +
                    --calendar work" );

     

       78
       82
        
               `S "RECURRENCE";

     

       79
       83
        
               `P

     

       80
       84
        
                 "Recurrence rule in iCalendar RFC5545 format. The FREQ part is \

+14 -5

bin/list_cmd.ml

···

       3
       3
        
       open Query_args

     

       4
       4
        
       

     

       5
       5
        
       let run ?from_str ?to_str ?calendar ?count ~format ~today ~tomorrow ~week ~month

     

       6
       6
       -
           ?timezone ~fs calendar_dir =

     

       6
       6
       +
           ?timezone ~sort ~fs calendar_dir =

     

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

     

       8
       8
        
         let tz = Query_args.parse_timezone ~timezone in

     

       9
       9
        
         let* from, to_ =

     
···

       55
       55
        
               Some (Query.in_collections [ Collection.Col collection_id ])

     

       56
       56
        
           | None -> None

     

       57
       57
        
         in

     

       58
       58
       +
         let comparator = Query_args.create_instance_comparator sort in

     

       58
       59
        
         let* results =

     

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

     

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

     

       60
       61
        
         in

     

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

     

       62
       63
        
         else

     
···

       66
       67
        
       

     

       67
       68
        
       let cmd ~fs calendar_dir =

     

       68
       69
        
         let run from_str to_str calendar count format today tomorrow week month

     

       69
       69
       -
             timezone =

     

       70
       70
       +
             timezone sort =

     

       70
       71
        
           match

     

       71
       72
        
             run ?from_str ?to_str ?calendar ?count ~format ~today ~tomorrow ~week

     

       72
       72
       -
               ~month ?timezone ~fs calendar_dir

     

       73
       73
       +
               ~month ?timezone ~sort ~fs calendar_dir

     

       73
       74
        
           with

     

       74
       75
        
           | Error (`Msg msg) ->

     

       75
       76
        
               Printf.eprintf "Error: %s\n%!" msg;

     
···

       79
       80
        
         let term =

     

       80
       81
        
           Term.(

     

       81
       82
        
             const run $ from_arg $ to_arg $ calendar_arg $ count_arg $ format_arg

     

       82
       82
       -
             $ today_arg $ tomorrow_arg $ week_arg $ month_arg $ timezone_arg)

     

       83
       83
       +
             $ today_arg $ tomorrow_arg $ week_arg $ month_arg $ timezone_arg

     

       84
       84
       +
             $ sort_arg)

     

       83
       85
        
         in

     

       84
       86
        
         let doc = "List calendar events" in

     

       85
       87
        
         let man =

     
···

       89
       91
        
             `P "By default, events from today to one month from today are shown.";

     

       90
       92
        
             `P "You can use date flags to show events for a specific time period.";

     

       91
       93
        
             `P "You can also filter events by calendar using the --calendar flag.";

     

       94
       94
       +
             `P "Use the --sort option to control the sorting of results.";

     

       92
       95
        
             `S Manpage.s_options;

     

       93
       96
        
           ]

     

       94
       97
        
           @ date_format_manpage_entries

     
···

       105
       108
        
                 ("List events from a specific calendar:", "caled list --calendar work");

     

       106
       109
        
               `I ("List events in JSON format:", "caled list --format json");

     

       107
       110
        
               `I ("Limit the number of events shown:", "caled list --count 5");

     

       111
       111
       +
               `I

     

       112
       112
       +
                 ( "Sort by multiple fields (start time and summary):",

     

       113
       113
       +
                   "caled list --sort start --sort summary" );

     

       114
       114
       +
               `I

     

       115
       115
       +
                 ( "Sort by calendar name in descending order:",

     

       116
       116
       +
                   "caled list --sort calendar:desc" );

     

       108
       117
        
             ]

     

       109
       118
        
         in

     

       110
       119
        
         let exit_info =

+106

bin/query_args.ml

···

       72
       72
        
           & opt (some string) None

     

       73
       73
        
           & info [ "timezone"; "z" ] ~docv:"TIMEZONE" ~doc)

     

       74
       74
        
       

     

       75
       75
       +
       let sort_field_enum =

     

       76
       76
       +
         [

     

       77
       77
       +
           ("start", `Start);

     

       78
       78
       +
           ("end", `End);

     

       79
       79
       +
           ("summary", `Summary);

     

       80
       80
       +
           ("location", `Location);

     

       81
       81
       +
           ("calendar", `Calendar);

     

       82
       82
       +
         ]

     

       83
       83
       +
       

     

       84
       84
       +
       type sort_spec = {

     

       85
       85
       +
         field : [ `Start | `End | `Summary | `Location | `Calendar ];

     

       86
       86
       +
         descending : bool;

     

       87
       87
       +
       }

     

       88
       88
       +
       

     

       89
       89
       +
       let parse_sort_spec str =

     

       90
       90
       +
         let ( let* ) = Result.bind in

     

       91
       91
       +
         let parts = String.split_on_char ':' str in

     

       92
       92
       +
         match parts with

     

       93
       93
       +
         | [] -> Error (`Msg "Empty sort specification")

     

       94
       94
       +
         | field_str :: order_opt -> (

     

       95
       95
       +
             let* descending =

     

       96
       96
       +
               match order_opt with

     

       97
       97
       +
               | [ "desc" ] | [ "descending" ] -> Ok true

     

       98
       98
       +
               | [ "asc" ] | [ "ascending" ] -> Ok false

     

       99
       99
       +
               | [] -> Ok false (* Default to ascending *)

     

       100
       100
       +
               | _ -> Error (`Msg ("Invalid sort order in: " ^ str))

     

       101
       101
       +
             in

     

       102
       102
       +
             match List.assoc_opt field_str sort_field_enum with

     

       103
       103
       +
             | Some field -> Ok { field; descending }

     

       104
       104
       +
             | None ->

     

       105
       105
       +
                 Error

     

       106
       106
       +
                   (`Msg

     

       107
       107
       +
                      (Printf.sprintf "Invalid sort field '%s'. Valid options are: %s"

     

       108
       108
       +
                         field_str

     

       109
       109
       +
                         (String.concat ", " (List.map fst sort_field_enum)))))

     

       110
       110
       +
       

     

       111
       111
       +
       let sort_converter =

     

       112
       112
       +
         let parse s = parse_sort_spec s in

     

       113
       113
       +
         let print ppf spec =

     

       114
       114
       +
           let field_str =

     

       115
       115
       +
             List.find_map

     

       116
       116
       +
               (fun (name, field) -> if field = spec.field then Some name else None)

     

       117
       117
       +
               sort_field_enum

     

       118
       118
       +
           in

     

       119
       119
       +
           let order_str = if spec.descending then ":desc" else "" in

     

       120
       120
       +
           Fmt.pf ppf "%s%s" (Option.value field_str ~default:"unknown") order_str

     

       121
       121
       +
         in

     

       122
       122
       +
         Arg.conv (parse, print)

     

       123
       123
       +
       

     

       124
       124
       +
       let default_sort = { field = `Start; descending = false }

     

       125
       125
       +
       

     

       126
       126
       +
       let sort_arg =

     

       127
       127
       +
         let doc =

     

       128
       128
       +
           "Sorting specifications in the format 'field[:order]' where field is one \

     

       129
       129
       +
            of 'start', 'end', 'summary', 'location', 'calendar' and order is one of \

     

       130
       130
       +
            'asc'/'ascending' or 'desc'/'descending' (default: asc). Multiple sort \

     

       131
       131
       +
            specs can be provided for multi-level sorting. When no sort is specified, \

     

       132
       132
       +
            defaults to sorting by start time ascending."

     

       133
       133
       +
         in

     

       134
       134
       +
         Arg.(

     

       135
       135
       +
           value

     

       136
       136
       +
           & opt_all sort_converter [ default_sort ]

     

       137
       137
       +
           & info [ "sort"; "s" ] ~docv:"SORT" ~doc)

     

       138
       138
       +
       

     

       139
       139
       +
       (* Convert sort specs to an instance comparator *)

     

       140
       140
       +
       let create_instance_comparator sort_specs =

     

       141
       141
       +
         match sort_specs with

     

       142
       142
       +
         | [] -> Recur.Instance.by_start

     

       143
       143
       +
         | [ spec ] ->

     

       144
       144
       +
             let comp =

     

       145
       145
       +
               match spec.field with

     

       146
       146
       +
               | `Start -> Recur.Instance.by_start

     

       147
       147
       +
               | `End -> Recur.Instance.by_end

     

       148
       148
       +
               | `Summary -> Recur.Instance.by_event Event.by_summary

     

       149
       149
       +
               | `Location -> Recur.Instance.by_event Event.by_location

     

       150
       150
       +
               | `Calendar -> Recur.Instance.by_event Event.by_collection

     

       151
       151
       +
             in

     

       152
       152
       +
             if spec.descending then Recur.Instance.descending comp else comp

     

       153
       153
       +
         | specs ->

     

       154
       154
       +
             (* Chain multiple sort specs together *)

     

       155
       155
       +
             List.fold_right

     

       156
       156
       +
               (fun spec acc ->

     

       157
       157
       +
                 let comp =

     

       158
       158
       +
                   match spec.field with

     

       159
       159
       +
                   | `Start -> Recur.Instance.by_start

     

       160
       160
       +
                   | `End -> Recur.Instance.by_end

     

       161
       161
       +
                   | `Summary -> Recur.Instance.by_event Event.by_summary

     

       162
       162
       +
                   | `Location -> Recur.Instance.by_event Event.by_location

     

       163
       163
       +
                   | `Calendar -> Recur.Instance.by_event Event.by_collection

     

       164
       164
       +
                 in

     

       165
       165
       +
                 let comp =

     

       166
       166
       +
                   if spec.descending then Recur.Instance.descending comp else comp

     

       167
       167
       +
                 in

     

       168
       168
       +
                 Recur.Instance.chain comp acc)

     

       169
       169
       +
               (List.tl specs)

     

       170
       170
       +
               (let spec = List.hd specs in

     

       171
       171
       +
                let comp =

     

       172
       172
       +
                  match spec.field with

     

       173
       173
       +
                  | `Start -> Recur.Instance.by_start

     

       174
       174
       +
                  | `End -> Recur.Instance.by_end

     

       175
       175
       +
                  | `Summary -> Recur.Instance.by_event Event.by_summary

     

       176
       176
       +
                  | `Location -> Recur.Instance.by_event Event.by_location

     

       177
       177
       +
                  | `Calendar -> Recur.Instance.by_event Event.by_collection

     

       178
       178
       +
                in

     

       179
       179
       +
                if spec.descending then Recur.Instance.descending comp else comp)

     

       180
       180
       +
       

     

       75
       181
        
       let date_format_manpage_entries =

     

       76
       182
        
         [

     

       77
       183
        
           `S "DATE FORMATS";

+16 -6

bin/search_cmd.ml

···

       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 ~fs calendar_dir =

     

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

     
···

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

     

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

     

       70
       70
        
         let filter = Query.and_filter !filters in

     

       71
       71
       +
         let comparator = Query_args.create_instance_comparator sort in

     

       71
       72
        
         let* results =

     

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

     

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

     

       73
       74
        
         in

     

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

     

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

     

       76
       76
       +
         else

     

       77
       77
       +
           print_endline

     

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

     

       76
       79
        
         Ok ()

     

       77
       80
        
       

     

       78
       81
        
       let query_text_arg =

     
···

       101
       104
        
       

     

       102
       105
        
       let cmd ~fs calendar_dir =

     

       103
       106
        
         let run query_text from_str to_str calendar count format summary description

     

       104
       104
       -
             location today tomorrow week month recurring non_recurring timezone =

     

       107
       107
       +
             location today tomorrow week month recurring non_recurring timezone sort =

     

       105
       108
        
           match

     

       106
       109
        
             run ?from_str ?to_str ?calendar ?count ?query_text ~summary ~description

     

       107
       110
        
               ~location ~format ~today ~tomorrow ~week ~month ~recurring

     

       108
       108
       -
               ~non_recurring ?timezone ~fs calendar_dir

     

       111
       111
       +
               ~non_recurring ?timezone ~sort ~fs calendar_dir

     

       109
       112
        
           with

     

       110
       113
        
           | Error (`Msg msg) ->

     

       111
       114
        
               Printf.eprintf "Error: %s\n%!" msg;

     
···

       117
       120
        
             const run $ query_text_arg $ from_arg $ to_arg $ calendar_arg $ count_arg

     

       118
       121
        
             $ format_arg $ summary_arg $ description_arg $ location_arg $ today_arg

     

       119
       122
        
             $ tomorrow_arg $ week_arg $ month_arg $ recurring_arg $ non_recurring_arg

     

       120
       120
       -
             $ timezone_arg)

     

       123
       123
       +
             $ timezone_arg $ sort_arg)

     

       121
       124
        
         in

     

       122
       125
        
         let doc = "Search calendar events for specific text" in

     

       123
       126
        
         let man =

     
···

       138
       141
        
             `P

     

       139
       142
        
               "You can limit results to only recurring or non-recurring events using \

     

       140
       143
        
                the --recurring or --non-recurring flags.";

     

       144
       144
       +
             `P "Use the --sort option to control the sorting of results.";

     

       141
       145
        
             `P

     

       142
       146
        
               "The search text is optional if you're using other filters. For \

     

       143
       147
        
                example, you can find all recurring events without specifying any \

     
···

       174
       178
        
               `I

     

       175
       179
        
                 ( "Find all events in a specific calendar:",

     

       176
       180
        
                   "caled search --calendar work" );

     

       181
       181
       +
               `I

     

       182
       182
       +
                 ( "Sort results by location and then summary:",

     

       183
       183
       +
                   "caled search --sort location --sort summary" );

     

       184
       184
       +
               `I

     

       185
       185
       +
                 ( "Sort results by end time in descending order:",

     

       186
       186
       +
                   "caled search --sort end:desc" );

     

       177
       187
        
             ]

     

       178
       188
        
         in

     

       179
       189
        
         let exit_info =

lib/event.ml

···

       227
       227
        
         | Collection.Col c1, Collection.Col c2 -> String.compare c1 c2

     

       228
       228
        
       

     

       229
       229
        
       let descending comp e1 e2 = -1 * comp e1 e2

     

       230
       230
       +
       

     

       231
       231
       +
       let chain comp1 comp2 e1 e2 =

     

       232
       232
       +
         let result = comp1 e1 e2 in

     

       233
       233
       +
         if result <> 0 then result else comp2 e1 e2

lib/event.mli

···

       97
       97
        
       

     

       98
       98
        
       val descending : comparator -> comparator

     

       99
       99
        
       (** Reverse the order of a comparator *)

     

       100
       100
       +
       

     

       101
       101
       +
       val chain : comparator -> comparator -> comparator

     

       102
       102
       +
       (** Chain two comparators together, using the second one as a tiebreaker when

     

       103
       103
       +
           the first one returns equality (0) *)

lib/recur.ml

···

       17
       17
        
       

     

       18
       18
        
         let by_event event_comp i1 i2 = event_comp i1.event i2.event

     

       19
       19
        
         let descending comp i1 i2 = -1 * comp i1 i2

     

       20
       20
       +
       

     

       21
       21
       +
         let chain comp1 comp2 i1 i2 =

     

       22
       22
       +
           let result = comp1 i1 i2 in

     

       23
       23
       +
           if result <> 0 then result else comp2 i1 i2

     

       20
       24
        
       end

     

       21
       25
        
       

     

       22
       26
        
       let clone_with_time original start =

+6 -2

lib/recur.mli

···

       11
       11
        
         (** Compare instances by start time, earlier times come first *)

     

       12
       12
        
       

     

       13
       13
        
         val by_end : comparator

     

       14
       14
       -
         (** Compare instances by end time, earlier times come first.

     

       15
       15
       -
             Instances with end times come after those without *)

     

       14
       14
       +
         (** Compare instances by end time, earlier times come first. Instances with

     

       15
       15
       +
             end times come after those without *)

     

       16
       16
        
       

     

       17
       17
        
         val by_event : Event.comparator -> comparator

     

       18
       18
        
         (** Apply an event comparator to instances *)

     

       19
       19
        
       

     

       20
       20
        
         val descending : comparator -> comparator

     

       21
       21
        
         (** Reverse the order of a comparator *)

     

       22
       22
       +
       

     

       23
       23
       +
         val chain : comparator -> comparator -> comparator

     

       24
       24
       +
         (** Chain two comparators together, using the second one as a tiebreaker when

     

       25
       25
       +
             the first one returns equality (0) *)

     

       22
       26
        
       end

     

       23
       27
        
       

     

       24
       28
        
       val expand_event :