batless 0.5.0

A non-blocking, LLM-friendly code viewer inspired by bat
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

//! Plain text and highlighted output formatters

use crate::config::BatlessConfig;
use crate::error::BatlessResult;
use crate::file_info::FileInfo;
use crate::formatter::OutputMode;
use crate::formatters::Formatter;
use crate::highlighter::SyntaxHighlighter;

/// Plain text formatter (no syntax highlighting)
pub struct PlainFormatter;

impl Formatter for PlainFormatter {
    fn format(
        &self,
        file_info: &FileInfo,
        _file_path: &str,
        _config: &BatlessConfig,
    ) -> BatlessResult<String> {
        let mut output = Vec::new();

        // For now, just return the content without line numbers
        // Line numbers would need to be added to BatlessConfig if required
        output.extend(file_info.lines.iter().cloned());

        Ok(output.join("\n"))
    }

    fn output_mode(&self) -> OutputMode {
        OutputMode::Plain
    }
}

/// Syntax highlighting formatter
pub struct HighlightFormatter;

impl Formatter for HighlightFormatter {
    fn format(
        &self,
        file_info: &FileInfo,
        file_path: &str,
        config: &BatlessConfig,
    ) -> BatlessResult<String> {
        // Use the highlighter's existing method
        SyntaxHighlighter::highlight_content(&file_info.lines.join("\n"), file_path, config)
    }

    fn output_mode(&self) -> OutputMode {
        OutputMode::Highlight
    }
}

/// Add line numbers to text lines
#[allow(dead_code)]
fn add_line_numbers(lines: &[String], number_nonblank_only: bool) -> Vec<String> {
    let mut result = Vec::new();
    let mut line_number = 1;

    for line in lines {
        if number_nonblank_only {
            // Only number non-blank lines (cat -b behavior)
            if line.trim().is_empty() {
                result.push(line.clone());
            } else {
                result.push(format!("{line_number:6}\t{line}"));
                line_number += 1;
            }
        } else {
            // Number all lines (cat -n behavior)
            result.push(format!("{line_number:6}\t{line}"));
            line_number += 1;
        }
    }

    result
}

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

    #[test]
    fn test_line_numbering() {
        let lines = vec!["line 1".to_string(), String::new(), "line 3".to_string()];

        let numbered = add_line_numbers(&lines, false);
        assert_eq!(numbered.len(), 3);
        assert!(numbered[0].contains("1\t"));
        assert!(numbered[2].contains("3\t"));

        let numbered_nonblank = add_line_numbers(&lines, true);
        assert_eq!(numbered_nonblank.len(), 3);
        assert!(numbered_nonblank[1].is_empty());
    }

    #[test]
    fn test_plain_formatter_mode() {
        let formatter = PlainFormatter;
        assert!(matches!(formatter.output_mode(), OutputMode::Plain));
    }
}