tldr-core 0.1.5

Core analysis engine for TLDR code analysis tool
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

use std::path::Path;

use tree_sitter::Node;

use super::super::language_profile::{
    node_text, LanguageNodeMap, LanguageProfile, LanguageSemantics, SignalAction,
};
use super::super::signals::{detect_naming_case, PatternSignals};

/// Semantic extractor for Elixir.
pub struct ElixirSemantics;

impl LanguageSemantics for ElixirSemantics {
    fn process_call(
        &self,
        call_id: &str,
        node: Node,
        source: &str,
        file_path: &Path,
        signals: &mut PatternSignals,
    ) {
        let call_text = node_text(node, source);

        match call_id {
            "defmodule" => {
                if let Some(name) = extract_identifier_arg(&call_text, "defmodule") {
                    let case = detect_naming_case(&name);
                    signals
                        .naming
                        .class_names
                        .push((name, case, file_path.display().to_string()));
                }
            }
            "def" | "defp" => {
                if let Some(name) = extract_identifier_arg(&call_text, call_id) {
                    let normalized = name.trim_end_matches("do").trim().to_string();
                    let function_name = normalized
                        .split('(')
                        .next()
                        .unwrap_or("")
                        .trim()
                        .to_string();
                    if !function_name.is_empty() {
                        let case = detect_naming_case(&function_name);
                        signals.naming.function_names.push((
                            function_name.clone(),
                            case,
                            file_path.display().to_string(),
                        ));
                        if function_name.starts_with("test") {
                            signals.test_idioms.test_function_count += 1;
                        }
                    }
                }
            }
            "import" | "alias" | "use" | "require" => {
                if let Some(module) = extract_identifier_arg(&call_text, call_id) {
                    signals
                        .import_patterns
                        .absolute_imports
                        .push((module, file_path.display().to_string()));
                }
            }
            "test" => {
                signals.test_idioms.test_function_count += 1;
            }
            _ => {}
        }
    }
}

fn extract_identifier_arg(call_text: &str, head: &str) -> Option<String> {
    let trimmed = call_text.trim_start();
    let remainder = trimmed.strip_prefix(head)?.trim_start();
    let first = remainder
        .split_whitespace()
        .next()
        .unwrap_or("")
        .trim_matches(',')
        .trim_matches('(')
        .trim_matches(')')
        .trim();
    if first.is_empty() {
        None
    } else {
        Some(first.to_string())
    }
}

/// Build the Elixir language profile.
pub fn profile() -> LanguageProfile {
    let mut map = LanguageNodeMap::new();
    map.call_dispatch
        .insert("defmodule", vec![SignalAction::CallSemantics]);
    map.call_dispatch
        .insert("def", vec![SignalAction::CallSemantics]);
    map.call_dispatch
        .insert("defp", vec![SignalAction::CallSemantics]);
    map.call_dispatch
        .insert("import", vec![SignalAction::CallSemantics]);
    map.call_dispatch
        .insert("alias", vec![SignalAction::CallSemantics]);
    map.call_dispatch
        .insert("use", vec![SignalAction::CallSemantics]);
    map.call_dispatch
        .insert("require", vec![SignalAction::CallSemantics]);
    map.call_dispatch
        .insert("test", vec![SignalAction::CallSemantics]);

    LanguageProfile {
        node_map: map,
        semantics: Box::new(ElixirSemantics),
    }
}