hyper-jump 0.10.0

A generalist all-in-one command-line version manager toolset for a more efficient development workflow.
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

mod commands;
mod dirs;
mod fs;
mod helpers;
mod packages;
mod proxy;
mod services;

use std::env;
use std::path::Path;
use std::path::PathBuf;

use clap::Parser;
use clap::Subcommand;
use clap::ValueEnum;
use commands::erase;
use commands::install;
use commands::list;
use commands::list_remote;
use commands::prefix;
use commands::uninstall;
use commands::use_cmd;
use helpers::client;
use proxy::handle_proxy;
use tracing::Level;
use tracing_indicatif::IndicatifLayer;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;

extern crate core;

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,

    #[arg(
        short,
        long,
        global = true,
        help = "root dir for config and data",
        env = "Hyper-jump_ROOT_DIR"
    )]
    root_dir: Option<PathBuf>,

    #[arg(
        short,
        long,
        global = true,
        help = "output format for command response",
        env = "Hyper-jump_OUTPUT_FORMAT"
    )]
    output_format: Option<OutputFormat>,
}

#[derive(ValueEnum, Clone)]
pub enum OutputFormat {
    Json,
    Table,
}

#[derive(Subcommand)]
enum Commands {
    Use(use_cmd::Args),
    List(list::Args),
    Install(install::Args),
    Uninstall(uninstall::Args),
    ListRemote(list_remote::Args),
    Prefix,
    Erase,
}

pub struct Context {
    pub dirs: dirs::Dirs,
    pub output_format: OutputFormat,
}

impl Context {
    fn for_cli(cli: &Cli) -> miette::Result<Self> {
        let dirs = dirs::Dirs::try_new(cli.root_dir.as_deref())?;
        let output_format = cli.output_format.clone().unwrap_or(OutputFormat::Table);

        Ok(Context {
            dirs,
            output_format,
        })
    }
}

pub fn with_tracing() {
    let indicatif_layer = IndicatifLayer::new();
    tracing_subscriber::registry()
        .with(tracing_subscriber::filter::LevelFilter::INFO)
        .with(tracing_subscriber::filter::Targets::default().with_target("hyper-jump", Level::INFO))
        .with(tracing_subscriber::fmt::layer().with_writer(indicatif_layer.get_stderr_writer()))
        .with(indicatif_layer)
        .init();
}

fn parse_args(args: Vec<String>) -> (String, Vec<String>) {
    let exe_name_path = Path::new(&args[0]);
    let exe_name = exe_name_path.file_stem().unwrap().to_str().unwrap();
    let rest_args = &args[1..];
    (exe_name.to_string(), rest_args.to_vec())
}

#[tokio::main]
async fn main() -> miette::Result<()> {
    tracing_subscriber::fmt::init();
    let args: Vec<String> = env::args().collect();
    let (exe_name, rest_args) = parse_args(args);

    if !exe_name.eq(env!("CARGO_PKG_NAME")) {
        return handle_proxy(&exe_name, &rest_args).await;
    }

    let cli = Cli::parse();
    let ctx = Context::for_cli(&cli)?;
    let client = Some(client::create_reqwest_client().map_err(|e| miette::miette!(e))?);

    match cli.command {
        Commands::Use(args) => use_cmd::run(args, &ctx, client.as_ref()).await,
        Commands::List(args) => list::run(args, &ctx, client.as_ref()).await,
        Commands::Install(args) => install::run(args, &ctx, client.as_ref()).await,
        Commands::Uninstall(args) => uninstall::run(args, &ctx, client.as_ref()).await,
        Commands::ListRemote(args) => list_remote::run(args, &ctx, client.as_ref()).await,
        Commands::Prefix => prefix::run().await,
        Commands::Erase => erase::run().await,
    }
}