hyper-jump 0.11.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

use std::fs;

use anyhow::anyhow;
use anyhow::Result;
use liblzma::read::XzDecoder;
use zip::ZipArchive as ZipReader;

use crate::domain::package::Package;
use crate::domain::version::LocalVersion;
use crate::ports::Archive;

pub struct LocalArchive;

impl Archive for LocalArchive {
    async fn extract(&self, package: Package, file: LocalVersion) -> anyhow::Result<()> {
        unarchive(package, file).await
    }
}

async fn unarchive(package: Package, file: LocalVersion) -> Result<()> {
    let path = format!("{}/{}.{}", file.path, file.file_name, file.file_format);
    tokio::task::spawn_blocking(move || expand(package, file))
        .await?
        .map_err(|e| anyhow!(e))?;

    tokio::fs::remove_file(path).await?;

    Ok(())
}

fn expand(package: Package, tmp: LocalVersion) -> Result<()> {
    use std::fs::File;
    use std::os::unix::fs::PermissionsExt;

    use anyhow::Context;
    use flate2::read::GzDecoder;
    use tar::Archive;

    if fs::metadata(&tmp.file_name).is_ok() {
        fs::remove_dir_all(&tmp.file_name)?;
    }

    let file_path = format!("{}/{}.{}", tmp.path, tmp.file_name, tmp.file_format);
    let file = File::open(&file_path).map_err(|error| {
        anyhow!(
            "Failed to open file {}.{}, file doesn't exist. additional info: {error}",
            tmp.file_name,
            tmp.file_format,
        )
    })?;

    let output = format!("{}/{}", tmp.path, tmp.file_name);

    let context_msg = format!(
        "Failed to decompress or extract file {}.{}",
        tmp.file_name, tmp.file_format
    );

    match tmp.file_format.as_str() {
        "tar.gz" => {
            let decompress_stream = GzDecoder::new(file);
            let mut archive = Archive::new(decompress_stream);
            archive.unpack(&output).with_context(|| context_msg)?;
        }
        "tar.xz" => {
            let decompress_stream = XzDecoder::new(file);
            let mut archive = Archive::new(decompress_stream);
            archive.unpack(&output).with_context(|| context_msg)?;
        }
        "zip" => {
            let mut archive = ZipReader::new(file)
                .map_err(|error| anyhow!("{context_msg}. additional info: {error}"))?;
            archive.extract(&output).with_context(|| context_msg)?;
        }
        _ => return Err(anyhow!("Unsupported file format")),
    }

    let binary = &format!(
        "{}/{}/{}",
        tmp.file_name,
        package.binary_path(),
        package.binary_name()
    );

    let mut perms = fs::metadata(binary)?.permissions();
    perms.set_mode(0o551);
    fs::set_permissions(binary, perms)?;

    Ok(())
}