ssh-utils 0.1.0

Utilities for ssh.
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
126
127
128
129
130
131
132
133

use clap_verbosity_flag::Verbosity;
use owo_colors::{
    OwoColorize,
    Stream::{Stderr, Stdout},
};
use std::cell::Cell;
use std::fmt::Arguments;
use std::mem::ManuallyDrop;
use std::ops::{Deref, DerefMut};

pub use log::Level;

pub fn eprintln_error_impl(args: &Arguments<'_>) {
    eprintln!("{}", args.if_supports_color(Stderr, |args| args.red()));
}

macro_rules! eprintln_error {
    ($fmt: expr) => {
        crate::utility::eprintln_error_impl(&std::format_args!($fmt))
    };

    ($fmt: expr, $($args: expr), *) => {
        crate::utility::eprintln_error_impl(&std::format_args!($fmt, $($args),*))
    };
}

pub(crate) use eprintln_error;

#[repr(transparent)]
pub struct BorrowCell<T>(Cell<T>);

impl<T> BorrowCell<T> {
    pub const fn new(value: T) -> Self {
        Self(Cell::new(value))
    }
}

impl<T: Default> BorrowCell<T> {
    pub fn borrow(&self) -> BorrowedCell<'_, T> {
        BorrowedCell(self, ManuallyDrop::new(self.0.take()))
    }
}

pub struct BorrowedCell<'a, T>(&'a BorrowCell<T>, ManuallyDrop<T>);

impl<T> Deref for BorrowedCell<'_, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &*self.1
    }
}

impl<T> DerefMut for BorrowedCell<'_, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut *self.1
    }
}

impl<T> Drop for BorrowedCell<'_, T> {
    fn drop(&mut self) {
        self.0 .0.set(unsafe { ManuallyDrop::take(&mut self.1) });
    }
}

pub trait PrintBasedOnVerbosity {
    /// Print to stdout only if the current log level is higher than `level`.
    fn print(&self, level: Level, args: &Arguments<'_>);

    /// Println to stdout only if the current log level is higher than `level`.
    fn println(&self, level: Level, args: &Arguments<'_>);

    /// Print to stdout only if the current log level is not quiet.
    fn print_if_not_quiet(&self, args: &Arguments<'_>);

    /// Println to stdout only if the current log level is not quiet.
    fn println_if_not_quiet(&self, args: &Arguments<'_>);
}

impl PrintBasedOnVerbosity for Verbosity {
    fn print(&self, level: Level, args: &Arguments<'_>) {
        match self.log_level() {
            Some(curr_level) if curr_level >= level => {
                if level == Level::Error {
                    eprintln_error_impl(args)
                } else if level == Level::Warn {
                    print!("{}", args.if_supports_color(Stdout, |args| args.yellow()));
                } else {
                    print!("{}", args);
                }
            }
            _ => (),
        }
    }

    fn println(&self, level: Level, args: &Arguments<'_>) {
        self.print(level, &std::format_args!("{args}\n"))
    }

    fn print_if_not_quiet(&self, args: &Arguments<'_>) {
        if self.log_level().is_some() {
            print!("{}", args);
        }
    }

    fn println_if_not_quiet(&self, args: &Arguments<'_>) {
        self.print_if_not_quiet(&std::format_args!("{args}\n"))
    }
}

macro_rules! println_on_level {
    ($verbosity:expr, $level:expr, $fmt: expr) => {
        crate::utility::PrintBasedOnVerbosity::println(&$verbosity, $level, &std::format_args!($fmt))
    };

    ($verbosity:expr, $level:expr, $fmt: expr, $($args: expr), *) => {
        crate::utility::PrintBasedOnVerbosity::println(&$verbosity, $level, &std::format_args!($fmt, $($args),*))
    };
}

pub(crate) use println_on_level;

macro_rules! println_if_not_quiet {
    ($verbosity:expr, $fmt: expr) => {
        crate::utility::PrintBasedOnVerbosity::println_if_not_quiet(&$verbosity, &std::format_args!($fmt))
    };

    ($verbosity:expr, $fmt: expr, $($args: expr), *) => {
        crate::utility::PrintBasedOnVerbosity::println_if_not_quiet(&$verbosity, &std::format_args!($fmt, $($args),*))
    };
}

pub(crate) use println_if_not_quiet;