hypershell-tokio-components 0.1.0-alpha

Modular DSL for shellscripting in Rust
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
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

#[cgp::re_export_imports]
mod preset {
    use std::path::PathBuf;
    use std::vec::Vec;

    use cgp::core::component::UseDelegate;
    use cgp::extra::handler::{HandlerComponent, PipeHandlers, UseInputDelegate};
    use cgp::prelude::{cgp_preset, *};
    use hypershell_components::components::{
        CommandArgExtractorComponent, CommandArgTypeProviderComponent,
    };
    use hypershell_components::dsl::{
        BytesToStream, FieldArg, FieldArgs, JoinArgs, ReadFile, SimpleExec, StaticArg,
        StreamToBytes, StreamToStdout, StreamToString, StreamingExec, WithArgs,
    };
    use hypershell_components::providers::{Call, ExtractStringCommandArg};

    use crate::components::CommandUpdaterComponent;
    use crate::dsl::CoreExec;
    use crate::providers::{
        ConvertBytesToStream, ConvertStreamToBytes, ConvertStreamToString, ExtractArgs,
        ExtractFieldArgs, FuturesToTokioStream, HandleCoreExec, HandleReadFile, HandleSimpleExec,
        HandleStreamToStdout, HandleStreamingExec, JoinExtractArgs, WrapTokioAsyncReadStream,
    };
    use crate::types::{FuturesAsyncReadStream, TokioAsyncReadStream};

    cgp_preset! {
        HypershellTokioPreset {
            CommandArgTypeProviderComponent:
                UseType<PathBuf>,
            HandlerComponent:
                TokioHandlerPreset::Provider,
            CommandArgExtractorComponent:
                CommandArgExtractorPreset::Provider,
            CommandUpdaterComponent:
                CommandUpdaterPreset::Provider,
        }
    }

    cgp_preset! {
        #[wrap_provider(UseDelegate)]
        TokioHandlerPreset {
            <Path, Args> SimpleExec<Path, Args>:
                HandleSimpleExec,
            <Path, Args> StreamingExec<Path, Args>:
                StreamingExecHandlers::Provider,
            <Path, Args> CoreExec<Path, Args>:
                HandleCoreExec,
            <Path> ReadFile<Path>:
                PipeHandlers<Product![
                    HandleReadFile,
                    WrapTokioAsyncReadStream,
                ]>,
            StreamToBytes:
                ConvertStreamToBytes,
            StreamToString:
                ConvertStreamToString,
            BytesToStream:
                ConvertBytesToStream,
            StreamToStdout:
                StreamingToStdoutHandlers::Provider,
        }
    }

    cgp_preset! {
        #[wrap_provider(UseDelegate)]
        CommandArgExtractorPreset {
            [
                <Arg> StaticArg<Arg>,
                <Tag> FieldArg<Tag>,
            ]: ExtractStringCommandArg,
            <Args> JoinArgs<Args>:
                JoinExtractArgs,
        }
    }

    cgp_preset! {
        #[wrap_provider(UseDelegate)]
        CommandUpdaterPreset {
            <Args> WithArgs<Args>: ExtractArgs,
            <Tag> FieldArgs<Tag>: ExtractFieldArgs,
        }
    }

    cgp_preset! {
        #[wrap_provider(UseInputDelegate)]
        StreamingToStdoutHandlers {
            <S> FuturesAsyncReadStream<S>:
                PipeHandlers<Product![
                    FuturesToTokioStream,
                    HandleStreamToStdout,
                ]>,
            <S> TokioAsyncReadStream<S>:
                HandleStreamToStdout,
            Vec<u8>:
                PipeHandlers<Product![
                    Call<BytesToStream>,
                    HandleStreamToStdout,
                ]>,
        }
    }

    cgp_preset! {
        #[wrap_provider(UseInputDelegate)]
        StreamingExecHandlers {
            <S> FuturesAsyncReadStream<S>:
                PipeHandlers<Product![
                    FuturesToTokioStream,
                    HandleStreamingExec,
                    WrapTokioAsyncReadStream,
                ]>,
            <S> TokioAsyncReadStream<S>:
                PipeHandlers<Product![
                    HandleStreamingExec,
                    WrapTokioAsyncReadStream,
                ]>,
            Vec<u8>:
                PipeHandlers<Product![
                    Call<BytesToStream>,
                    HandleStreamingExec,
                    WrapTokioAsyncReadStream,
                ]>,
        }
    }
}