buup 0.25.5

Core transformation library with zero dependencies
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

use crate::{Transform, TransformError};

/// Binary Encode transformer
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub struct BinaryEncode;

impl Transform for BinaryEncode {
    fn name(&self) -> &'static str {
        "Binary Encode"
    }

    fn id(&self) -> &'static str {
        "binaryencode"
    }

    fn description(&self) -> &'static str {
        "Encode text into its binary representation (space-separated bytes)."
    }

    fn category(&self) -> crate::TransformerCategory {
        crate::TransformerCategory::Encoder
    }

    fn transform(&self, input: &str) -> Result<String, TransformError> {
        if input.is_empty() {
            return Ok(String::new());
        }

        let binary_chunks: Vec<String> =
            input.bytes().map(|byte| format!("{:08b}", byte)).collect();

        Ok(binary_chunks.join(" "))
    }

    fn default_test_input(&self) -> &'static str {
        "Hello, World!"
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_binary_encode_empty() {
        let transformer = BinaryEncode;
        let result = transformer.transform("").unwrap();
        assert_eq!(result, "");
    }

    #[test]
    fn test_binary_encode_simple() {
        let transformer = BinaryEncode;
        let result = transformer.transform("Hi").unwrap();
        // H = 72 = 01001000, i = 105 = 01101001
        assert_eq!(result, "01001000 01101001");
    }

    #[test]
    fn test_binary_encode_with_punctuation() {
        let transformer = BinaryEncode;
        let result = transformer
            .transform(transformer.default_test_input())
            .unwrap();
        // H=72, e=101, l=108, l=108, o=111, ,=44,  =32, W=87, o=111, r=114, l=108, d=100, !=33
        let expected = "01001000 01100101 01101100 01101100 01101111 00101100 00100000 01010111 01101111 01110010 01101100 01100100 00100001";
        assert_eq!(result, expected);
    }

    #[test]
    fn test_binary_encode_unicode() {
        let transformer = BinaryEncode;
        // Example: Unicode character '✓' (U+2713)
        // UTF-8 representation: E2 9C 93
        // Binary: 11100010 10011100 10010011
        let result = transformer.transform("✓").unwrap();
        assert_eq!(result, "11100010 10011100 10010011");
    }
}