hac-cli 0.2.0

your handy API client, on your terminal!
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use std::path::Path;

use clap::Parser;

/// How the runtime should behave. Dictated by the flags provided to  `Cli`
#[derive(Debug, PartialEq)]
pub enum RuntimeBehavior {
    /// will print all directories `HAC` is looking for a configuration file
    /// that means. Will print wether or not HAC_CONFIG is set, and if so where
    /// it points to, will print `$XDG_CONFIG_HOME`, and also `$HOME/.config`
    PrintConfigPath,
    /// will print all directories `HAC` is looking for collections, this will
    /// also print the path specified on the configuration file, if any.
    PrintDataPath,
    /// will dump the default configuration to stdout instead of running the
    /// application.
    DumpDefaultConfig,
    /// will run the application with all disk-synchronization disabled. That
    /// means `HAC` wont't save any files or changes to collection to disk.
    DryRun,
    /// the default running behavior of the application, this is the default
    /// behavior for `HAC`.
    Run,
}

#[derive(Parser, Debug)]
pub struct Cli {
    /// prints the directory in which the config file is being loaded from
    #[arg(long)]
    config_dir: bool,
    /// dumps the default configuration to stdout.
    #[arg(long)]
    config_dump: bool,
    /// prints the directory in which the collections are being stored
    #[arg(long)]
    data_dir: bool,
    /// wether or not we should sync changes to the disk, when --dry-run is
    /// specified, no collection, request, or anything will be saved to disk.
    #[arg(long)]
    dry_run: bool,
}

impl Cli {
    pub fn parse_args() -> RuntimeBehavior {
        let args = Cli::parse();

        if args.config_dir {
            return RuntimeBehavior::PrintConfigPath;
        }
        if args.data_dir {
            return RuntimeBehavior::PrintDataPath;
        }
        if args.config_dump {
            return RuntimeBehavior::DumpDefaultConfig;
        }
        if args.dry_run {
            return RuntimeBehavior::DryRun;
        }

        RuntimeBehavior::Run
    }

    pub fn print_data_path<P>(data_path: P)
    where
        P: AsRef<Path>,
    {
        println!(
            "collections are being stored at: {}",
            data_path.as_ref().to_string_lossy()
        );
        println!("you can change this on the configuration file by specifying `collections_dir`");
    }

    pub fn print_config_path<P>(maybe_path: Option<P>, usual_path: P)
    where
        P: AsRef<Path>,
    {
        match maybe_path {
            Some(config_dir) => {
                println!(
                    "config is being loaded from: {}",
                    config_dir.as_ref().to_string_lossy()
                );
            }
            None => {
                println!("no config file was found, the default one is being used");
                println!("the usual path for the configuration file is at:\n");
                println!("{}", usual_path.as_ref().to_string_lossy());
            }
        }
    }

    pub fn print_default_config(config_as_str: &str) {
        println!("{}", config_as_str)
    }
}