commit 9bcc0178e40c088f9f78f27a0c097a26a8fca255 · anil.recoil.org/slop

+4 -1

stack/cacheio/bin/cache_cli.ml

···

       3
       3
        
       open Cmdliner

     

       4
       4
        
       

     

       5
       5
        
       let main () =

     

       6
       6
       +
         (* Default app name for the cache CLI tool *)

     

       7
       7
       +
         let app_name = "cacheio-cli" in

     

       8
       8
       +
       

     

       6
       9
        
         (* Run with Eio to provide the filesystem *)

     

       7
       10
        
         Eio_main.run @@ fun env ->

     

       8
       11
        
         let fs = env#fs in

     
···

       14
       17
        
           `P "This tool provides subcommands for listing, clearing, and managing cached files.";

     

       15
       18
        
         ] in

     

       16
       19
        
         let info = Cmd.info "cache" ~doc ~man in

     

       17
       17
       -
         let cmd = Cmd.group info (Cacheio_cmd.make_commands fs) in

     

       20
       20
       +
         let cmd = Cmd.group info (Cacheio_cmd.make_commands ~app_name fs) in

     

       18
       21
        
       

     

       19
       22
        
         exit (Cmd.eval cmd)

     

       20
       23

+7 -1

stack/cacheio/lib/cacheio.ml

···

       337
       337
        
       

     

       338
       338
        
       let pp fmt t =

     

       339
       339
        
         Format.fprintf fmt "Cache{base=%s}"

     

       340
       340
       -
           (Path.native_exn t.base_dir)
     

       340
       340
       +
           (Path.native_exn t.base_dir)

     

       341
       341
       +
       

     

       342
       342
       +
       (** {1 Convenience Functions} *)

     

       343
       343
       +
       

     

       344
       344
       +
       let create_with_xdge xdge =

     

       345
       345
       +
         let base_dir = Xdge.cache_dir xdge in

     

       346
       346
       +
         create ~base_dir

+3

stack/cacheio/lib/cacheio.mli

···

       15
       15
        
       (** Create a new cache at the specified base directory *)

     

       16
       16
        
       val create : base_dir:Eio.Fs.dir_ty Eio.Path.t -> t

     

       17
       17
        
       

     

       18
       18
       +
       (** Create a new cache using an Xdge context *)

     

       19
       19
       +
       val create_with_xdge : Xdge.t -> t

     

       20
       20
       +
       

     

       18
       21
        
       (** Check if a key exists in the cache.

     

       19
       22
        
           Keys are strings that will be automatically hashed for filesystem storage. *)

     

       20
       23
        
       val exists : t -> key:string -> bool

+21 -23

stack/cacheio/lib/cacheio_cmd.ml

···

       5
       5
        
       

     

       6
       6
        
       (** {1 Common Terms} *)

     

       7
       7
        
       

     

       8
       8
       -
       let cache_dir_term =

     

       9
       9
       -
         let doc = "Cache directory path" in

     

       10
       10
       -
         let env = Cmd.Env.info "CACHE_DIR" ~doc:"Override default cache directory" in

     

       11
       11
       -
         Arg.(value & opt string (Sys.getenv_opt "XDG_CACHE_HOME" |> Option.value ~default:"~/.cache")

     

       12
       12
       -
              & info ["cache-dir"; "c"] ~env ~docv:"PATH" ~doc)

     

       8
       8
       +
       let cache_dir_term ~app_name =

     

       9
       9
       +
         (* Use Xdge.Cmd.cache_term for proper XDG handling *)

     

       10
       10
       +
         Xdge.Cmd.cache_term app_name

     

       13
       11
        
       

     

       14
       12
        
       (** {1 Commands} *)

     

       15
       13
        
       

     

       16
       16
       -
       let list_cmd fs =

     

       14
       14
       +
       let list_cmd ~app_name fs =

     

       17
       15
        
         let list cache_dir stale expired pinned temporary older_than =

     

       18
       16
        
           let base_dir = Path.(fs / cache_dir) in

     

       19
       17
        
           let cache = Cacheio.create ~base_dir in

     
···

       70
       68
        
       

     

       71
       69
        
         let doc = "List cache entries" in

     

       72
       70
        
         let info = Cmd.info "list" ~doc in

     

       73
       73
       -
         Cmd.v info Term.(const list $ cache_dir_term $ stale $ expired $ pinned $ temporary $ older_than)

     

       71
       71
       +
         Cmd.v info Term.(const list $ cache_dir_term ~app_name $ stale $ expired $ pinned $ temporary $ older_than)

     

       74
       72
        
       

     

       75
       75
       -
       let expire_cmd fs =

     

       73
       73
       +
       let expire_cmd ~app_name fs =

     

       76
       74
        
         let expire cache_dir =

     

       77
       75
        
           let base_dir = Path.(fs / cache_dir) in

     

       78
       76
        
           let cache = Cacheio.create ~base_dir in

     
···

       82
       80
        
       

     

       83
       81
        
         let doc = "Remove expired entries from cache" in

     

       84
       82
        
         let info = Cmd.info "expire" ~doc in

     

       85
       85
       -
         Cmd.v info Term.(const expire $ cache_dir_term)

     

       83
       83
       +
         Cmd.v info Term.(const expire $ cache_dir_term ~app_name)

     

       86
       84
        
       

     

       87
       87
       -
       let clear_cmd fs =

     

       85
       85
       +
       let clear_cmd ~app_name fs =

     

       88
       86
        
         let clear cache_dir all temporary =

     

       89
       87
        
           let base_dir = Path.(fs / cache_dir) in

     

       90
       88
        
           let cache = Cacheio.create ~base_dir in

     
···

       106
       104
        
       

     

       107
       105
        
         let doc = "Clear cache entries" in

     

       108
       106
        
         let info = Cmd.info "clear" ~doc in

     

       109
       109
       -
         Cmd.v info Term.(const clear $ cache_dir_term $ all $ temporary)

     

       107
       107
       +
         Cmd.v info Term.(const clear $ cache_dir_term ~app_name $ all $ temporary)

     

       110
       108
        
       

     

       111
       111
       -
       let flag_cmd fs =

     

       109
       109
       +
       let flag_cmd ~app_name fs =

     

       112
       110
        
         let flag cache_dir key add remove set_flags =

     

       113
       111
        
           let base_dir = Path.(fs / cache_dir) in

     

       114
       112
        
           let cache = Cacheio.create ~base_dir in

     
···

       173
       171
        
       

     

       174
       172
        
         let doc = "Manage cache entry flags" in

     

       175
       173
        
         let info = Cmd.info "flag" ~doc in

     

       176
       176
       -
         Cmd.v info Term.(const flag $ cache_dir_term $ key $ add $ remove $ set_flags)

     

       174
       174
       +
         Cmd.v info Term.(const flag $ cache_dir_term ~app_name $ key $ add $ remove $ set_flags)

     

       177
       175
        
       

     

       178
       178
       -
       let stats_cmd fs =

     

       176
       176
       +
       let stats_cmd ~app_name fs =

     

       179
       177
        
         let stats cache_dir =

     

       180
       178
        
           let base_dir = Path.(fs / cache_dir) in

     

       181
       179
        
           let cache = Cacheio.create ~base_dir in

     
···

       200
       198
        
       

     

       201
       199
        
         let doc = "Show cache statistics" in

     

       202
       200
        
         let info = Cmd.info "stats" ~doc in

     

       203
       203
       -
         Cmd.v info Term.(const stats $ cache_dir_term)

     

       201
       201
       +
         Cmd.v info Term.(const stats $ cache_dir_term ~app_name)

     

       204
       202
        
       

     

       205
       203
        
       (** {1 Command Groups} *)

     

       206
       204
        
       

     

       207
       207
       -
       let make_commands fs = [

     

       208
       208
       -
         list_cmd fs;

     

       209
       209
       -
         expire_cmd fs;

     

       210
       210
       -
         clear_cmd fs;

     

       211
       211
       -
         flag_cmd fs;

     

       212
       212
       -
         stats_cmd fs

     

       205
       205
       +
       let make_commands ~app_name fs = [

     

       206
       206
       +
         list_cmd ~app_name fs;

     

       207
       207
       +
         expire_cmd ~app_name fs;

     

       208
       208
       +
         clear_cmd ~app_name fs;

     

       209
       209
       +
         flag_cmd ~app_name fs;

     

       210
       210
       +
         stats_cmd ~app_name fs

     

       213
       211
        
       ]

     

       214
       212
        
       

     

       215
       215
       -
       let make_cmd fs =

     

       213
       213
       +
       let make_cmd ~app_name fs =

     

       216
       214
        
         let doc = "Cache management commands" in

     

       217
       215
        
         let info = Cmd.info "cache" ~doc in

     

       218
       218
       -
         Cmd.group info (make_commands fs)
     

       216
       216
       +
         Cmd.group info (make_commands ~app_name fs)

+15 -15

stack/cacheio/lib/cacheio_cmd.mli

···

       9
       9
        
       

     

       10
       10
        
       (** {1 Common Terms} *)

     

       11
       11
        
       

     

       12
       12
       -
       (** Term for cache directory path *)

     

       13
       13
       -
       val cache_dir_term : string Cmdliner.Term.t

     

       12
       12
       +
       (** Term for cache directory path with proper XDG handling *)

     

       13
       13
       +
       val cache_dir_term : app_name:string -> string Cmdliner.Term.t

     

       14
       14
        
       

     

       15
       15
        
       (** {1 Command Builders} *)

     

       16
       16
        
       

     

       17
       17
       -
       (** Create list command with given filesystem *)

     

       18
       18
       -
       val list_cmd : Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       17
       17
       +
       (** Create list command with given filesystem and app name *)

     

       18
       18
       +
       val list_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       19
       19
        
       

     

       20
       20
       -
       (** Create expire command with given filesystem *)

     

       21
       21
       -
       val expire_cmd : Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       20
       20
       +
       (** Create expire command with given filesystem and app name *)

     

       21
       21
       +
       val expire_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       22
       22
        
       

     

       23
       23
       -
       (** Create clear command with given filesystem *)

     

       24
       24
       -
       val clear_cmd : Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       23
       23
       +
       (** Create clear command with given filesystem and app name *)

     

       24
       24
       +
       val clear_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       25
       25
        
       

     

       26
       26
       -
       (** Create flag management command with given filesystem *)

     

       27
       27
       -
       val flag_cmd : Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       26
       26
       +
       (** Create flag management command with given filesystem and app name *)

     

       27
       27
       +
       val flag_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       28
       28
        
       

     

       29
       29
       -
       (** Create statistics command with given filesystem *)

     

       30
       30
       -
       val stats_cmd : Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       29
       29
       +
       (** Create statistics command with given filesystem and app name *)

     

       30
       30
       +
       val stats_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       31
       31
        
       

     

       32
       32
        
       (** {1 Command Groups} *)

     

       33
       33
        
       

     

       34
       34
       -
       (** Create all cache commands for the given filesystem *)

     

       35
       35
       -
       val make_commands : Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t list

     

       34
       34
       +
       (** Create all cache commands for the given filesystem and app name *)

     

       35
       35
       +
       val make_commands : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t list

     

       36
       36
        
       

     

       37
       37
        
       (** Create main command group containing all cache subcommands *)

     

       38
       38
       -
       val make_cmd : Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t
     

       38
       38
       +
       val make_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

+2 -2

stack/cacheio/lib/dune

···

       2
       2
        
        (public_name cacheio)

     

       3
       3
        
        (name cacheio)

     

       4
       4
        
        (modules cacheio cacheio_flags cacheio_entry cacheio_stats)

     

       5
       5
       -
        (libraries eio eio_main digestif yojson ptime ptime.clock.os logs fmt))

     

       5
       5
       +
        (libraries eio eio_main digestif yojson ptime ptime.clock.os logs fmt xdge))

     

       6
       6
        
       

     

       7
       7
        
       (library

     

       8
       8
        
        (public_name cacheio.cmd)

     

       9
       9
        
        (name cacheio_cmd)

     

       10
       10
        
        (modules cacheio_cmd)

     

       11
       11
       -
        (libraries cacheio cmdliner eio eio_main))

     

       11
       11
       +
        (libraries cacheio cmdliner eio eio_main xdge))

+11 -1

stack/cacheio/test/dune

···

       1
       1
        
       (executable

     

       2
       2
        
        (public_name test_new_cache)

     

       3
       3
        
        (name test_new_cache)

     

       4
       4
       -
        (libraries cacheio eio_main))
     

       4
       4
       +
        (libraries cacheio eio_main))

     

       5
       5
       +
       

     

       6
       6
       +
       (executable

     

       7
       7
       +
        (public_name test_xdg)

     

       8
       8
       +
        (name test_xdg)

     

       9
       9
       +
        (libraries cacheio xdge eio_main))

     

       10
       10
       +
       

     

       11
       11
       +
       (executable

     

       12
       12
       +
        (public_name test_xdg_cmd)

     

       13
       13
       +
        (name test_xdg_cmd)

     

       14
       14
       +
        (libraries cacheio xdge cmdliner eio_main))

-1

stack/cacheio/xdg-eio

···

       1
       1
       -
       ../xdg-eio