sview 0.1.3

Agent-friendly structure views of source and document files
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

use crate::{
    cpp::analyze_cpp_like,
    java::analyze_java,
    javascript::analyze_javascript,
    kotlin::analyze_kotlin,
    markdown::analyze_markdown,
    model::{Language, Node, StructureView},
    objc::analyze_objc,
    rust::analyze_rust,
    swift::analyze_swift,
    util::{file_name, first_non_empty_preview},
};
use anyhow::{Context, Result};
use std::{fs, path::Path};

pub fn analyze_file(path: &Path, preview_len: usize) -> Result<StructureView> {
    let source =
        fs::read_to_string(path).with_context(|| format!("failed to read {}", path.display()))?;
    let language = detect_language(path, &source);
    Ok(analyze_source(
        path.to_string_lossy().as_ref(),
        language,
        &source,
        preview_len,
    ))
}

pub fn analyze_source(
    path: &str,
    language: Language,
    source: &str,
    preview_len: usize,
) -> StructureView {
    let line_count = source.lines().count().max(1);
    let nodes = if source.trim().is_empty() {
        Vec::new()
    } else if matches!(language, Language::C | Language::Cpp) {
        analyze_cpp_like(language, source, preview_len)
    } else if matches!(
        language,
        Language::JavaScript | Language::TypeScript | Language::Tsx
    ) {
        analyze_javascript(language, source, preview_len)
    } else if language == Language::Java {
        analyze_java(source, preview_len)
    } else if language == Language::Kotlin {
        analyze_kotlin(source, preview_len)
    } else if language == Language::ObjectiveC {
        analyze_objc(source, preview_len)
    } else if language == Language::Swift {
        analyze_swift(source, preview_len)
    } else if language == Language::Markdown {
        analyze_markdown(source, preview_len)
    } else if language == Language::Rust {
        analyze_rust(source, preview_len)
    } else {
        vec![Node {
            kind: "file".to_string(),
            level: None,
            name: Some(file_name(path)),
            start_line: 1,
            end_line: line_count,
            preview: first_non_empty_preview(source, preview_len),
            children: Vec::new(),
        }]
    };

    StructureView {
        path: path.to_string(),
        language,
        nodes,
    }
}

pub fn detect_language(path: &Path, source: &str) -> Language {
    match path.extension().and_then(|extension| extension.to_str()) {
        Some("h") if looks_like_objc(source) => Language::ObjectiveC,
        Some("c" | "h") => Language::C,
        Some("cc" | "cpp" | "cxx" | "hh" | "hpp" | "hxx") => Language::Cpp,
        Some("java") => Language::Java,
        Some("js" | "jsx") => Language::JavaScript,
        Some("kt" | "kts") => Language::Kotlin,
        Some("md" | "markdown" | "mdown") => Language::Markdown,
        Some("m" | "mm") => Language::ObjectiveC,
        Some("rs") => Language::Rust,
        Some("swift") => Language::Swift,
        Some("ts") => Language::TypeScript,
        Some("tsx") => Language::Tsx,
        _ if source.trim_start().starts_with("# ") => Language::Markdown,
        _ => Language::Unknown,
    }
}

fn looks_like_objc(source: &str) -> bool {
    let trimmed = source.trim_start();
    trimmed.starts_with("#import")
        || trimmed.contains("@interface")
        || trimmed.contains("@implementation")
        || trimmed.contains("@protocol")
}