use serde::{Deserialize, Serialize};
pub const DEFAULT_MAX_LINES: usize = 2000;
pub const DEFAULT_MAX_BYTES: usize = 50 * 1024;
pub const GREP_MAX_LINE_LENGTH: usize = 500;
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TruncationResult {
pub content: String,
pub truncated: bool,
pub truncated_by: Option<String>, pub output_lines: usize,
pub total_lines: usize,
pub max_lines: Option<usize>,
pub max_bytes: Option<usize>,
pub first_line_exceeds_limit: bool,
pub output_bytes: usize,
pub last_line_partial: bool,
}
pub fn truncate_head(content: &str, max_lines: Option<usize>, max_bytes: Option<usize>) -> TruncationResult {
let max_lines = max_lines.unwrap_or(DEFAULT_MAX_LINES);
let max_bytes = max_bytes.unwrap_or(DEFAULT_MAX_BYTES);
let mut lines: Vec<&str> = content.split('\n').collect();
if content.ends_with('\n') {
lines.pop();
}
let total_lines = lines.len();
if !lines.is_empty() {
let first_line_bytes = lines[0].len();
if first_line_bytes > max_bytes {
return TruncationResult {
first_line_exceeds_limit: true,
total_lines,
max_bytes: Some(max_bytes),
max_lines: Some(max_lines),
..Default::default()
};
}
}
let mut out: Vec<&str> = Vec::new();
let mut bytes = 0usize;
let mut truncated_by: Option<String> = None;
for line in &lines {
let line_bytes = line.len() + 1; if out.len() + 1 > max_lines {
truncated_by = Some("lines".into());
break;
}
if bytes + line_bytes > max_bytes {
truncated_by = Some("bytes".into());
break;
}
bytes += line_bytes;
out.push(line);
}
let truncated = truncated_by.is_some();
let content = out.join("\n");
TruncationResult {
output_bytes: content.len(),
content,
truncated,
truncated_by,
output_lines: out.len(),
total_lines,
max_lines: Some(max_lines),
max_bytes: Some(max_bytes),
first_line_exceeds_limit: false,
last_line_partial: false,
}
}
pub fn truncate_tail(content: &str, max_lines: Option<usize>, max_bytes: Option<usize>) -> TruncationResult {
let max_lines = max_lines.unwrap_or(DEFAULT_MAX_LINES);
let max_bytes = max_bytes.unwrap_or(DEFAULT_MAX_BYTES);
let mut lines: Vec<&str> = content.split('\n').collect();
if content.ends_with('\n') {
lines.pop();
}
let total_lines = lines.len();
let start = total_lines.saturating_sub(max_lines);
let mut kept: Vec<&str> = lines[start..].to_vec();
let mut truncated_by = if start > 0 { Some("lines".into()) } else { None };
let total_bytes: usize = kept.iter().map(|l| l.len() + 1).sum();
if total_bytes > max_bytes {
let mut bytes = 0usize;
let mut cut_from = 0;
for (i, line) in kept.iter().enumerate().rev() {
bytes += line.len() + 1;
if bytes > max_bytes {
cut_from = i + 1;
truncated_by = Some("bytes".into());
break;
}
}
if cut_from >= kept.len() {
cut_from = kept.len().saturating_sub(1);
}
kept = kept[cut_from..].to_vec();
}
let truncated = truncated_by.is_some();
let content = kept.join("\n");
let output_lines = kept.len();
TruncationResult {
output_bytes: content.len(),
content,
truncated,
truncated_by,
output_lines,
total_lines,
max_lines: Some(max_lines),
max_bytes: Some(max_bytes),
first_line_exceeds_limit: false,
last_line_partial: false,
}
}
pub fn truncate_line(line: &str, max: Option<usize>) -> (String, bool) {
let max = max.unwrap_or(GREP_MAX_LINE_LENGTH);
let chars: Vec<char> = line.chars().collect();
if chars.len() <= max {
return (line.to_string(), false);
}
let truncated: String = chars[..max].iter().collect();
(format!("{truncated}…"), true)
}
pub fn format_size(bytes: usize) -> String {
const KB: f64 = 1024.0;
const MB: f64 = KB * 1024.0;
let b = bytes as f64;
if b >= MB {
format!("{:.1}MB", b / MB)
} else if b >= KB {
format!("{:.1}KB", b / KB)
} else {
format!("{}B", bytes)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn head_truncates_by_lines() {
let content = "a\nb\nc\nd\ne";
let r = truncate_head(content, Some(2), Some(1024));
assert_eq!(r.content, "a\nb");
assert!(r.truncated);
assert_eq!(r.truncated_by.as_deref(), Some("lines"));
}
#[test]
fn tail_keeps_recent_lines() {
let content = "a\nb\nc\nd\ne";
let r = truncate_tail(content, Some(2), Some(1024));
assert_eq!(r.content, "d\ne");
assert!(r.truncated);
}
#[test]
fn line_truncation_is_char_safe() {
let s = "日本語".repeat(1000);
let (t, truncated) = truncate_line(&s, Some(10));
assert!(truncated);
assert!(t.chars().count() <= 11);
}
#[test]
fn head_does_not_inflate_line_count_for_trailing_newline() {
let r = truncate_head("a\nb\nc\n", Some(2000), Some(1024));
assert_eq!(r.total_lines, 3);
assert_eq!(r.output_lines, 3);
assert!(!r.truncated);
}
#[test]
fn tail_does_not_inflate_line_count_for_trailing_newline() {
let r = truncate_tail("a\nb\nc\n", Some(2000), Some(1024));
assert_eq!(r.total_lines, 3);
assert_eq!(r.output_lines, 3);
assert!(!r.truncated);
}
#[test]
fn tail_truncation_reports_an_exact_line_range() {
let r = truncate_tail("1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n", Some(3), Some(1024));
assert_eq!(r.total_lines, 10);
assert_eq!(r.output_lines, 3);
assert_eq!(r.content, "8\n9\n10");
assert!(r.truncated);
}
}