treesearch 1.0.8

Structure-aware document search CLI. Fast keyword matching over hierarchical document trees.
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

//! JSON output format for search results.
//!
//! Serializes results as a JSON object with a `version` field and `results` array
//! using `serde_json::to_string_pretty` for human-readable output.

use serde::Serialize;

use crate::document::SearchResult;

use super::OutputFormat;

/// Schema version for the JSON output format.
const SCHEMA_VERSION: &str = "1.0";

/// Top-level JSON output envelope.
#[derive(Serialize)]
struct JsonEnvelope<'a> {
    version: &'static str,
    results: &'a [SearchResult],
}

/// JSON output formatter.
pub struct JsonOutput;

impl JsonOutput {
    pub fn new() -> Self {
        Self
    }
}

impl Default for JsonOutput {
    fn default() -> Self {
        Self::new()
    }
}

impl OutputFormat for JsonOutput {
    fn render(&self, results: &[SearchResult], _verbose: u8) -> String {
        let envelope = JsonEnvelope {
            version: SCHEMA_VERSION,
            results,
        };
        serde_json::to_string_pretty(&envelope).unwrap_or_else(|e| {
            format!("{{\"error\": \"serialization failed: {}\"}}", e)
        })
    }
}

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

    fn sample_result() -> SearchResult {
        SearchResult {
            node_id: "1".into(),
            doc_id: "doc1".into(),
            doc_name: "test.md".into(),
            title: "Test Title".into(),
            summary: "A test summary".into(),
            text: "Some body text".into(),
            source_type: "markdown".into(),
            source_path: "docs/test.md".into(),
            line_start: Some(1),
            line_end: Some(10),
            score: 0.95,
            depth: 0,
            breadcrumb: vec!["Root".into(), "Test Title".into()],
        }
    }

    #[test]
    fn test_json_output_has_version() {
        let json_out = JsonOutput::new();
        let output = json_out.render(&[sample_result()], 0);
        assert!(output.contains("\"version\": \"1.0\""));
    }

    #[test]
    fn test_json_output_has_results() {
        let json_out = JsonOutput::new();
        let output = json_out.render(&[sample_result()], 0);
        assert!(output.contains("\"results\""));
        assert!(output.contains("\"Test Title\""));
        assert!(output.contains("0.95"));
    }

    #[test]
    fn test_json_output_empty() {
        let json_out = JsonOutput::new();
        let output = json_out.render(&[], 0);
        assert!(output.contains("\"version\": \"1.0\""));
        assert!(output.contains("\"results\": []"));
    }

    #[test]
    fn test_json_output_valid_json() {
        let json_out = JsonOutput::new();
        let output = json_out.render(&[sample_result()], 0);
        let parsed: serde_json::Value = serde_json::from_str(&output).unwrap();
        assert_eq!(parsed["version"], "1.0");
        assert!(parsed["results"].is_array());
        assert_eq!(parsed["results"].as_array().unwrap().len(), 1);
    }

    #[test]
    fn test_json_output_pretty_printed() {
        let json_out = JsonOutput::new();
        let output = json_out.render(&[sample_result()], 0);
        // Pretty-printed JSON should contain newlines and indentation
        assert!(output.contains('\n'));
        assert!(output.contains("  "));
    }

    #[test]
    fn test_json_output_multiple_results() {
        let json_out = JsonOutput::new();
        let results = vec![sample_result(), sample_result()];
        let output = json_out.render(&results, 0);
        let parsed: serde_json::Value = serde_json::from_str(&output).unwrap();
        assert_eq!(parsed["results"].as_array().unwrap().len(), 2);
    }
}