use std::io::{self, Read};
pub const TEXT_PROBE_LEN: usize = 1024;
const fn is_text_byte(b: u8) -> bool {
matches!(b, 7..=13 | 27 | 0x20..=0x7e | 0x80..=0xff)
}
#[must_use]
pub fn is_text_bytes(content: &[u8]) -> bool {
let head = content.get(..TEXT_PROBE_LEN).unwrap_or(content);
head.chunks(64)
.all(|chunk| chunk.iter().fold(true, |ok, &b| ok & is_text_byte(b)))
}
pub fn is_text<R: Read>(mut reader: R) -> io::Result<bool> {
let mut buf = [0u8; TEXT_PROBE_LEN];
let n = read_full(&mut reader, &mut buf)?;
Ok(is_text_bytes(buf.get(..n).unwrap_or_default()))
}
pub(crate) fn read_full<R: Read + ?Sized>(reader: &mut R, buf: &mut [u8]) -> io::Result<usize> {
let mut filled = 0;
while let Some(rest) = buf.get_mut(filled..) {
if rest.is_empty() {
break;
}
match reader.read(rest) {
Ok(0) => break,
Ok(n) => filled += n.min(rest.len()),
Err(e) if e.kind() == io::ErrorKind::Interrupted => {}
Err(e) => return Err(e),
}
}
Ok(filled)
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Cursor;
#[test]
fn upstream_is_text_cases() {
for (data, expected) in [
(&b"hello world"[..], true),
(b"", true),
("éóñəå ⊂(◉‿◉)つ(ノ≥∇≤)ノ".as_bytes(), true),
(r"¯\_(ツ)_/¯".as_bytes(), true),
("♪┏(・o・)┛♪┗ ( ・o・) ┓♪┏ ( ) ┛♪┗ (・o・ ) ┓♪".as_bytes(), true),
(b"\xe9\xf3\xf1\xe5", true),
(b"hello world\x00", false),
(b"\x7f\x45\x4c\x46\x02\x01\x01", false),
(b"\x43\x92\xd9\x0f\xaf\x32\x2c", false),
] {
assert_eq!(is_text_bytes(data), expected, "{data:?}");
assert_eq!(is_text(Cursor::new(data)).ok(), Some(expected), "{data:?}");
}
}
#[test]
fn only_first_1024_bytes_count() {
let mut data = vec![b'a'; TEXT_PROBE_LEN];
data.push(0);
assert!(is_text_bytes(&data));
assert!(is_text(Cursor::new(&data)).unwrap_or(false));
data[TEXT_PROBE_LEN - 1] = 0;
assert!(!is_text_bytes(&data));
}
#[test]
fn short_reads_are_completed() {
let reader = Cursor::new(b"abc".to_vec()).chain(Cursor::new(b"\x00\x01".to_vec()));
assert!(!is_text(reader).unwrap_or(true));
}
#[test]
fn interrupted_reads_are_retried() {
struct Flaky(u8);
impl Read for Flaky {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
self.0 += 1;
match self.0 {
1 => Err(io::ErrorKind::Interrupted.into()),
2 => {
buf[0] = 0;
Ok(1)
}
_ => Ok(0),
}
}
}
assert!(!is_text(Flaky(0)).unwrap_or(true));
}
#[test]
fn byte_classes() {
for b in 0u8..=255 {
let expected = matches!(b, 7 | 8 | 9 | 10 | 11 | 12 | 13 | 27)
|| (0x20..0x7f).contains(&b)
|| b >= 0x80;
assert_eq!(is_text_bytes(&[b]), expected, "{b:#x}");
}
}
}