broot 0.13.3

Fuzzy Search + tree + cd
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
126
127
128
129
130
131
132
133
134
135
136

//! This module is where is defined whether broot
//! writes on stdout, on stderr or elsewhere. It also provides helper
//! structs for io.
use std::{
    fmt,
    io::{self, Write},
};

/// the type used by all GUI writing functions
pub type W = std::io::Stderr;

/// return the writer used by the application
pub fn writer() -> W {
    std::io::stderr()
}

/// RAII wrapper for writer to control state transitions.
pub struct WriteCleanup<W, F, E>
where
    W: Write,
    F: Fn(&mut W) -> Result<(), E>,
    E: fmt::Display,
{
    writer: W,
    cleanup: F,
}

impl<W, F, E> WriteCleanup<W, F, E>
where
    W: Write,
    F: Fn(&mut W) -> Result<(), E>,
    E: fmt::Display,
{
    #[inline]
    pub fn new(writer: W, cleanup: F) -> Self {
        WriteCleanup { writer, cleanup }
    }

    #[inline]
    pub fn build<E2, F2: Fn(&mut W) -> Result<(), E2>>(
        mut writer: W,
        build: F2,
        cleanup: F,
    ) -> Result<Self, E2> {
        build(&mut writer)?;
        Ok(Self::new(writer, cleanup))
    }
}

impl<W, F, E> Drop for WriteCleanup<W, F, E>
where
    W: Write,
    F: Fn(&mut W) -> Result<(), E>,
    E: fmt::Display,
{
    fn drop(&mut self) {
        if let Err(err) = (self.cleanup)(&mut self.writer) {
            warn!("Error cleaning up terminal: {}", err);
        }
    }
}

impl<W, F, E> fmt::Debug for WriteCleanup<W, F, E>
where
    W: Write + fmt::Debug,
    F: Fn(&mut W) -> Result<(), E>,
    E: fmt::Display,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("WriteCleanup")
            .field("writer", &self.writer)
            .field("cleanup", &"<closure>")
            .finish()
    }
}

impl<W, F, E> Write for WriteCleanup<W, F, E>
where
    W: Write,
    F: Fn(&mut W) -> Result<(), E>,
    E: fmt::Display,
{
    #[inline]
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        self.writer.write(buf)
    }

    #[inline]
    fn flush(&mut self) -> io::Result<()> {
        self.writer.flush()
    }

    #[inline]
    fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> {
        self.writer.write_vectored(bufs)
    }

    #[inline]
    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
        self.writer.write_all(buf)
    }

    #[inline]
    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
        self.writer.write_fmt(fmt)
    }
}

#[test]
fn test_write_cleanup() -> io::Result<()> {
    use std::str;

    let mut buffer: Vec<u8> = Vec::new();

    {
        let writer = WriteCleanup::build(
            &mut buffer,
            |writer| write!(writer, "abc "),
            |writer| write!(writer, " xyz"),
        )?;

        let mut writer = WriteCleanup::build(
            writer,
            |writer| write!(writer, "123 "),
            |writer| write!(writer, " 789"),
        )?;

        write!(&mut writer, "Hello, World!")?;
    }

    let result = str::from_utf8(&buffer).unwrap();

    assert_eq!(result, "abc 123 Hello, World! 789 xyz");

    Ok(())
}