sem-reg 0.1.1

Handle certain Windows registry binary values semantically. Extensible.
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

use std::fmt::{self};

pub struct HexBytes<'a> {
    bytes: &'a [u8],
    old_bytes: Option<&'a [u8]>,
}

impl<'a> HexBytes<'a> {
    pub fn new(bytes: &'a [u8]) -> Self {
        Self {
            bytes,
            old_bytes: None,
        }
    }

    pub fn diff_against(mut self, old_bytes: &'a [u8]) -> Self {
        //! This will introduce ANSI escape sequences in the output to color it.

        self.old_bytes = Some(old_bytes);
        self
    }
}

impl fmt::Display for HexBytes<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let write_byte = |f: &mut fmt::Formatter<'_>, first: bool, byte| -> fmt::Result {
            if !first {
                write!(f, " ")?;
            }
            write!(f, "{byte:02x}")?;
            Ok(())
        };

        let mut first = true;
        if let Some(other_bytes) = self.old_bytes {
            let mut current_color = Color::Default;
            write!(f, "{current_color}")?;

            for fragment in diff::slice(other_bytes, self.bytes) {
                let (byte, byte_color) = match fragment {
                    diff::Result::Left(byte) => (byte, Color::BrightRed),
                    diff::Result::Right(byte) => (byte, Color::BrightGreen),
                    diff::Result::Both(byte, _) => (byte, Color::Default),
                };

                if byte_color != current_color {
                    write!(f, "{byte_color}")?;
                    current_color = byte_color;
                }

                write_byte(f, first, byte)?;

                first = false;
            }

            if current_color != Color::Default {
                write!(f, "{}", Color::Default)?;
            }
        } else {
            for byte in self.bytes {
                write_byte(f, first, byte)?;
                first = false;
            }
        }

        Ok(())
    }
}

#[derive(Clone, Copy, PartialEq)]
enum Color {
    Default,
    BrightRed,
    BrightGreen,
}

impl fmt::Display for Color {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{}",
            match self {
                // See <https://chrisyeh96.github.io/2020/03/28/terminal-colors.html>.
                Color::Default => "\x1b[0m",
                Color::BrightRed => "\x1b[91m",
                Color::BrightGreen => "\x1b[92m",
            }
        )?;

        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use crate::data_conversion::hex_bytes::HexBytes;

    #[test]
    fn diff_output() {
        assert_eq!(
            HexBytes::new(&[0x10, 0xf1, 0xf2, 0x13])
                .diff_against(&[0x10, 0x11, 0x12, 0x13])
                .to_string(),
            String::new()
                + "\x1b[0m"
                + "10"
                + "\x1b[91m"
                + " 11 12"
                + "\x1b[92m"
                + " f1 f2"
                + "\x1b[0m"
                + " 13"
        );
    }
}