nu_plugin_compress 0.2.2

A nushell plugin for compression and decompression, supporting zstd, gzip, bzip2, and xz.
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::io::BufReader;

use crate::CompressPlugin;
use bzip2::bufread::BzDecoder;
use nu_plugin::PluginCommand;
use nu_protocol::{
    ByteStream, ByteStreamType, Category, LabeledError, PipelineData, Signature, Type,
};
use xz2::bufread::XzDecoder;

pub enum DecompressCommand {
    Gzip,
    Zstd,
    Xz,
    Bzip2,
}

impl PluginCommand for DecompressCommand {
    type Plugin = CompressPlugin;

    fn name(&self) -> &str {
        match self {
            DecompressCommand::Gzip => "from gz",
            DecompressCommand::Zstd => "from zst",
            DecompressCommand::Xz => "from xz",
            DecompressCommand::Bzip2 => "from bz2",
        }
    }

    fn signature(&self) -> Signature {
        Signature::build(PluginCommand::name(self))
            .allow_variants_without_examples(true)
            .input_output_types(vec![(Type::Binary, Type::Any)])
            .category(Category::Experimental)
            .filter()
    }

    fn description(&self) -> &str {
        match self {
            DecompressCommand::Gzip => "Decompress with gzip.",
            DecompressCommand::Zstd => "Decompress with zstd.",
            DecompressCommand::Xz => "Decompress with xz.",
            DecompressCommand::Bzip2 => "Decompress with bzip2.",
        }
    }

    fn run(
        &self,
        _plugin: &Self::Plugin,
        engine: &nu_plugin::EngineInterface,
        call: &nu_plugin::EvaluatedCall,
        input: nu_protocol::PipelineData,
    ) -> Result<nu_protocol::PipelineData, nu_protocol::LabeledError> {
        match input {
            PipelineData::ByteStream(byte_stream, pipeline_metadata) => {
                let span = byte_stream.span();
                let reader = BufReader::new(byte_stream.reader().unwrap());
                let stream = match self {
                    DecompressCommand::Gzip => ByteStream::read(
                        flate2::read::GzDecoder::new(reader),
                        span,
                        engine.signals().clone(),
                        ByteStreamType::Binary,
                    ),
                    DecompressCommand::Zstd => ByteStream::read(
                        zstd::stream::Decoder::new(reader)
                            .map_err(|e| LabeledError::new(e.to_string()))?,
                        span,
                        engine.signals().clone(),
                        ByteStreamType::Binary,
                    ),
                    DecompressCommand::Xz => ByteStream::read(
                        XzDecoder::new(reader),
                        span,
                        engine.signals().clone(),
                        ByteStreamType::Binary,
                    ),
                    DecompressCommand::Bzip2 => ByteStream::read(
                        BzDecoder::new(reader),
                        span,
                        engine.signals().clone(),
                        ByteStreamType::Binary,
                    ),
                };
                Ok(PipelineData::ByteStream(stream, pipeline_metadata))
            }
            v => {
                return Err(LabeledError::new(format!(
                    "requires binary input, got {}",
                    v.get_type()
                ))
                .with_label("Expected binary from pipeline", call.head))
            }
        }
    }
}