vers 0.5.0

Install and manage dev tools with multiple environments
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

use super::{Archiver, ArchiverError};
use async_trait::async_trait;
use std::{fs::File, path::Path};
use tar::Archive;
use tracing::debug;

pub struct TarArchiver;

#[async_trait]
impl Archiver for TarArchiver {
    async fn extract_to(&self, file_path: &'_ Path, out_dir: &'_ Path) -> super::Result<()> {
        tracing::debug!(
            "Extracting {} using the 'Tar' Archiver",
            file_path.display()
        );
        let file = File::open(file_path).map_err(|open_err| ArchiverError::IoError {
            file_path: file_path.to_path_buf(),
            source: open_err,
        })?;
        let mut archive = Archive::new(file);

        if let Ok(entries) = archive.entries() {
            for entry in entries {
                match entry {
                    Ok(mut file) => {
                        let out_file_name = file.path().unwrap();
                        debug!(
                            "Extracting '{}' from archive '{}'",
                            out_file_name.display(),
                            file_path.display()
                        );
                        // Write the file to the specified path
                        file.unpack_in(out_dir).map_err(|unpack_err| {
                            ArchiverError::ExtractorError {
                                extractor: "tar".to_string(),
                                message: unpack_err.to_string(),
                            }
                        })?;
                    }
                    Err(entry_err) => {
                        return Err(ArchiverError::ExtractorError {
                            extractor: "tar".to_string(),
                            message: format!(
                                "Unable to extract file from archive {}. {:?}",
                                file_path.display(),
                                entry_err,
                            ),
                        })
                    }
                }
            }
        } else {
            return Err(ArchiverError::ExtractorError {
                extractor: "tar".to_string(),
                message: format!(
                    "Unable to get archiver entries from {}",
                    file_path.display()
                ),
            });
        }

        Ok(())
    }

    async fn extract(&self, file_path: &'_ Path) -> super::Result<()> {
        self.extract_to(file_path, Path::new(".")).await
    }

    fn can_handle(&self, file_path: &'_ Path) -> bool {
        file_path
            .file_name()
            .map(|f| f.to_str().unwrap_or_default().ends_with(".tar"))
            .unwrap_or_default()
    }

    fn name(&self) -> &'static str {
        "tar"
    }
}