aopt-shell 0.3.2

A flexible and typed getopt tools
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

use std::io::Write;
use std::marker::PhantomData;

use crate::acore::opt::Opt;
use crate::acore::Error;
use crate::shell::Shell;
use crate::SHELL_PSH;
use crate::SHELL_PSH7;

pub struct PowerShell<O, W> {
    name: &'static str,
    w: Option<W>,
    __marker: PhantomData<O>,
}

impl<O, W> Default for PowerShell<O, W> {
    fn default() -> Self {
        Self {
            name: SHELL_PSH,
            w: Default::default(),
            __marker: Default::default(),
        }
    }
}

impl<O, W> PowerShell<O, W> {
    pub fn new() -> Self {
        Self {
            name: SHELL_PSH,
            w: None,
            __marker: PhantomData,
        }
    }

    pub fn new7() -> Self {
        Self {
            name: SHELL_PSH7,
            w: None,
            __marker: PhantomData,
        }
    }

    pub fn buffer(&mut self) -> Result<&mut W, Error> {
        self.w
            .as_mut()
            .ok_or_else(|| crate::error!("must set buffer before write to"))
    }

    pub fn with_buffer(mut self, w: W) -> Self {
        self.w = Some(w);
        self
    }
}

macro_rules! wln2buf {
    ($w:expr, $fmt:literal, $($arg:tt)*) => {
        writeln!( $w, $fmt, $($arg)* )
            .map_err(|e| $crate::error!("can not write to buffer: {e:?}"))
    };
}

impl<O, W> Shell<O, W> for PowerShell<O, W>
where
    W: Write,
    O: Opt,
{
    type Err = Error;

    fn is_avail(&self, name: &str) -> bool {
        name == self.name
    }

    fn set_buff(&mut self, w: W) {
        self.w = Some(w);
    }

    fn write_cmd(&mut self, name: &str, opt: &O) -> Result<(), Self::Err> {
        if opt.help().is_empty() {
            wln2buf!(self.buffer()?, "{}", name)
        } else {
            wln2buf!(self.buffer()?, "{}\t{}", name, opt.help())
        }
    }

    fn write_opt(&mut self, name: &str, opt: &O) -> Result<(), Self::Err> {
        if opt.help().is_empty() {
            wln2buf!(self.buffer()?, "{}", name)
        } else {
            wln2buf!(self.buffer()?, "{}\t{}", name, opt.help())
        }
    }

    fn write_pos(&mut self, name: &str, opt: &O) -> Result<(), Self::Err> {
        if opt.help().is_empty() {
            wln2buf!(self.buffer()?, "{}", name)
        } else {
            wln2buf!(self.buffer()?, "{}\t{}", name, opt.help())
        }
    }

    fn write_val(&mut self, val: &std::ffi::OsStr, _: &O) -> Result<(), Self::Err> {
        wln2buf!(self.buffer()?, "{}", val.display())
    }

    fn write_eq(&mut self, name: &str, val: &std::ffi::OsStr, _: &O) -> Result<(), Self::Err> {
        wln2buf!(self.buffer()?, "{}={}", name, val.display())
    }

    fn finish(&mut self) -> Result<(), Self::Err> {
        Ok(())
    }

    fn take_buff(&mut self) -> Option<W> {
        self.w.take()
    }
}