commit de59b45cdac7ea313cd9bfdc047f30b065eaf03a · ryan.freumh.org/caledonia

+5 -1

bin/query_args.ml

···

       35
       35
        
         ]

     

       36
       36
        
       

     

       37
       37
        
       let format_arg =

     

       38
       38
       -
         let doc = "Output format (text, entries, json, csv, ics, sexp)" in

     

       38
       38
       +
         let doc =

     

       39
       39
       +
           "Output format (text, entries, json, csv, ics, sexp). Note that dates are \

     

       40
       40
       +
            localised to the TIMEZONE option but the timezone they're defined in is \

     

       41
       41
       +
            displayed."

     

       42
       42
       +
         in

     

       39
       43
        
         Arg.(

     

       40
       44
        
           value

     

       41
       45
        
           & opt (enum format_enum) `Text

+63 -10

lib/event.ml

···

       168
       168
        
       let get_start_timezone t =

     

       169
       169
        
         match t.event.dtstart with

     

       170
       170
        
         | _, `Datetime (`With_tzid (_, (_, tzid))) -> Some tzid

     

       171
       171
       +
         | _, `Datetime (`Utc _) -> Some "UTC"

     

       172
       172
       +
         | _, `Datetime (`Local _) -> Some "FLOATING"

     

       171
       173
        
         | _ -> None

     

       172
       174
        
       

     

       173
       175
        
       let get_end_timezone t =

     

       174
       176
        
         match t.event.dtend_or_duration with

     

       175
       177
        
         | Some (`Dtend (_, `Datetime (`With_tzid (_, (_, tzid))))) -> Some tzid

     

       178
       178
       +
         | Some (`Dtend (_, `Datetime (`Utc _))) -> Some "UTC"

     

       179
       179
       +
         | Some (`Dtend (_, `Datetime (`Local _))) -> Some "FLOATING"

     

       176
       180
        
         | _ -> None

     

       177
       181
        
       

     

       178
       182
        
       let get_duration t =

     
···

       386
       390
        
         let start = get_start event in

     

       387
       391
        
         let end_ = get_end event in

     

       388
       392
        
         let start_date = format_date ?tz start in

     

       393
       393
       +
         let start_timezone = get_start_timezone event in

     

       394
       394
       +
         let end_timezone = get_end_timezone event in

     

       395
       395
       +
         let same_timezone =

     

       396
       396
       +
           match (start_timezone, end_timezone) with

     

       397
       397
       +
           | Some tz1, Some tz2 when tz1 = tz2 -> true

     

       398
       398
       +
           | _ -> false

     

       399
       399
       +
         in

     

       389
       400
        
         let start_time =

     

       390
       390
       -
           match is_date event with true -> "" | false -> " " ^ format_time ?tz start

     

       401
       401
       +
           match is_date event with

     

       402
       402
       +
           | true -> ""

     

       403
       403
       +
           | false ->

     

       404
       404
       +
               let tz_str =

     

       405
       405
       +
                 if same_timezone then " " ^ format_time ?tz start

     

       406
       406
       +
                 else

     

       407
       407
       +
                   match start_timezone with

     

       408
       408
       +
                   | Some tzid -> " " ^ format_time ?tz start ^ " (" ^ tzid ^ ")"

     

       409
       409
       +
                   | None -> " " ^ format_time ?tz start

     

       410
       410
       +
               in

     

       411
       411
       +
               tz_str

     

       391
       412
        
         in

     

       392
       413
        
         let end_date, end_time =

     

       393
       414
        
           match end_ with

     
···

       400
       421
        
                   | false -> (" - " ^ format_date ?tz end_, ""))

     

       401
       422
        
               | false -> (

     

       402
       423
        
                   match day_diff start ~next:end_ == 0 with

     

       403
       403
       -
                   | true -> ("", " - " ^ format_time ?tz end_)

     

       404
       404
       -
                   | false -> (" - " ^ format_date ?tz end_, " " ^ format_time ?tz end_)

     

       405
       405
       -
                   ))

     

       424
       424
       +
                   | true ->

     

       425
       425
       +
                       let tz_str =

     

       426
       426
       +
                         match end_timezone with

     

       427
       427
       +
                         | Some tzid when same_timezone ->

     

       428
       428
       +
                             ("", " - " ^ format_time ?tz end_ ^ " (" ^ tzid ^ ")")

     

       429
       429
       +
                         | Some tzid ->

     

       430
       430
       +
                             ("", " - " ^ format_time ?tz end_ ^ " (" ^ tzid ^ ")")

     

       431
       431
       +
                         | None -> ("", " - " ^ format_time ?tz end_)

     

       432
       432
       +
                       in

     

       433
       433
       +
                       tz_str

     

       434
       434
       +
                   | false ->

     

       435
       435
       +
                       let tz_str =

     

       436
       436
       +
                         match end_timezone with

     

       437
       437
       +
                         | Some tzid when same_timezone ->

     

       438
       438
       +
                             ( " - " ^ format_date ?tz end_,

     

       439
       439
       +
                               " " ^ format_time ?tz end_ ^ " (" ^ tzid ^ ")" )

     

       440
       440
       +
                         | Some tzid ->

     

       441
       441
       +
                             ( " - " ^ format_date ?tz end_,

     

       442
       442
       +
                               " " ^ format_time ?tz end_ ^ " (" ^ tzid ^ ")" )

     

       443
       443
       +
                         | None ->

     

       444
       444
       +
                             (" - " ^ format_date ?tz end_, " " ^ format_time ?tz end_)

     

       445
       445
       +
                       in

     

       446
       446
       +
                       tz_str))

     

       406
       447
        
         in

     

       407
       448
        
         let summary =

     

       408
       449
        
           match get_summary event with

     
···

       433
       474
        
               Option.map (fun x -> Printf.sprintf "%s: %s\n" label (f x)) opt

     

       434
       475
        
               |> Option.value ~default:""

     

       435
       476
        
             in

     

       436
       436
       -
             let format timezone datetime =

     

       477
       477
       +
             let start_timezone = get_start_timezone event in

     

       478
       478
       +
             let end_timezone = get_end_timezone event in

     

       479
       479
       +
             let same_timezone =

     

       480
       480
       +
               match (start_timezone, end_timezone) with

     

       481
       481
       +
               | Some tz1, Some tz2 when tz1 = tz2 -> true

     

       482
       482
       +
               | _ -> false

     

       483
       483
       +
             in

     

       484
       484
       +
             let format timezone datetime is_end =

     

       437
       485
        
               match is_date event with

     

       438
       486
        
               | true -> format_date ?tz datetime

     

       439
       439
       -
               | false -> (

     

       440
       440
       -
                   format_datetime ?tz datetime

     

       441
       441
       -
                   ^ match timezone with None -> "" | Some t -> " (" ^ t ^ ")")

     

       487
       487
       +
               | false ->

     

       488
       488
       +
                   let tz_suffix =

     

       489
       489
       +
                     if (not is_end) && same_timezone then ""

     

       490
       490
       +
                     else match timezone with None -> "" | Some t -> " (" ^ t ^ ")"

     

       491
       491
       +
                   in

     

       492
       492
       +
                   format_datetime ?tz datetime ^ tz_suffix

     

       442
       493
        
             in

     

       443
       494
        
             let start_str =

     

       444
       444
       -
               format_opt "Start" (format (get_start_timezone event)) (Some start)

     

       495
       495
       +
               format_opt "Start" (fun d -> format start_timezone d false) (Some start)

     

       445
       496
        
             in

     

       446
       446
       -
             let end_str = format_opt "End" (format (get_end_timezone event)) end_ in

     

       497
       497
       +
             let end_str =

     

       498
       498
       +
               format_opt "End" (fun d -> format end_timezone d true) end_

     

       499
       499
       +
             in

     

       447
       500
        
             let location_str = format_opt "Location" Fun.id (get_location event) in

     

       448
       501
        
             let description_str =

     

       449
       502
        
               format_opt "Description" Fun.id (get_description event)