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
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
137
138
139
140
141
142
143
144
145
146

use crate::{Transform, TransformError};

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

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

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

    fn description(&self) -> &'static str {
        "Decode space-separated binary representation back to text."
    }

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

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

        let bytes: Result<Vec<u8>, _> = input
            .split_whitespace()
            .map(|s| {
                if s.len() != 8 || !s.chars().all(|c| c == '0' || c == '1') {
                    Err(TransformError::InvalidArgument(
                        format!("Invalid 8-bit binary chunk: '{}'", s).into(),
                    ))
                } else {
                    u8::from_str_radix(s, 2).map_err(|e| {
                        TransformError::InvalidArgument(
                            format!("Failed to parse binary chunk '{}': {}", s, e).into(),
                        )
                    })
                }
            })
            .collect();

        let bytes = bytes?;

        String::from_utf8(bytes).map_err(|e| {
            TransformError::InvalidArgument(format!("Invalid UTF-8 sequence: {}", e).into())
        })
    }

    fn default_test_input(&self) -> &'static str {
        "01001000 01100101 01101100 01101100 01101111 00101100 00100000 01010111 01101111 01110010 01101100 01100100 00100001"
        // "Hello, World!"
    }
}

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

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

    #[test]
    fn test_binary_decode_simple() {
        let transformer = BinaryDecode;
        let result = transformer.transform("01001000 01101001").unwrap(); // "Hi"
        assert_eq!(result, "Hi");
    }

    #[test]
    fn test_binary_decode_with_punctuation() {
        let transformer = BinaryDecode;
        let result = transformer
            .transform(transformer.default_test_input())
            .unwrap();
        assert_eq!(result, "Hello, World!");
    }

    #[test]
    fn test_binary_decode_unicode() {
        let transformer = BinaryDecode;
        let input = "11100010 10011100 10010011"; // '✓'
        let result = transformer.transform(input).unwrap();
        assert_eq!(result, "✓");
    }

    #[test]
    fn test_binary_decode_invalid_length() {
        let transformer = BinaryDecode;
        let result = transformer.transform("01001000 1101001"); // Second chunk is too short
        assert!(result.is_err());
        match result {
            Err(TransformError::InvalidArgument(msg)) => {
                assert!(msg.contains("Invalid 8-bit binary chunk: '1101001'"));
            }
            _ => panic!("Expected InvalidArgument error"),
        }
    }

    #[test]
    fn test_binary_decode_invalid_chars() {
        let transformer = BinaryDecode;
        let result = transformer.transform("01001000 0110100a"); // Contains 'a'
        assert!(result.is_err());
        match result {
            Err(TransformError::InvalidArgument(msg)) => {
                assert!(msg.contains("Invalid 8-bit binary chunk: '0110100a'"));
            }
            _ => panic!("Expected InvalidArgument error"),
        }
    }

    #[test]
    fn test_binary_decode_invalid_utf8() {
        let transformer = BinaryDecode;
        let result = transformer.transform("11110000 10011111 10011111"); // Invalid UTF-8 start byte
        assert!(result.is_err());
        match result {
            Err(TransformError::InvalidArgument(msg)) => {
                assert!(msg.contains("Invalid UTF-8 sequence"));
            }
            _ => panic!("Expected InvalidArgument error"),
        }
    }

    #[test]
    fn test_binary_decode_trailing_space() {
        let transformer = BinaryDecode;
        let result = transformer.transform("01001000 ").unwrap(); // "H"
        assert_eq!(result, "H");
    }

    #[test]
    fn test_binary_decode_leading_space() {
        let transformer = BinaryDecode;
        let result = transformer.transform(" 01001000").unwrap(); // "H"
        assert_eq!(result, "H");
    }
}