relay-knowledge 1.1.10

Graph-database-based knowledge graph project.
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

use std::collections::BTreeMap;

use crate::domain::RepositoryCodeSymbolRecord;

pub(in crate::code) fn enrich_symbol_identities(
    repository_id: &str,
    symbols: &mut [RepositoryCodeSymbolRecord],
) {
    let symbol_metadata = symbols
        .iter()
        .enumerate()
        .map(|(index, symbol)| SymbolIdentityMetadata {
            index,
            path: symbol.path.clone(),
            name: symbol.name.clone(),
            kind: symbol.kind.clone(),
            line_start: symbol.line_range.start,
            line_end: symbol.line_range.end,
            byte_start: symbol.byte_range.start,
            byte_end: symbol.byte_range.end,
            prefix: path_prefix(&symbol.qualified_name).to_owned(),
            explicit_segments: explicit_qualified_segments(&symbol.qualified_name, &symbol.name),
        })
        .collect::<Vec<_>>();
    let mut by_path = BTreeMap::<&str, Vec<usize>>::new();
    for (metadata_index, metadata) in symbol_metadata.iter().enumerate() {
        by_path
            .entry(metadata.path.as_str())
            .or_default()
            .push(metadata_index);
    }

    for metadata_indices in by_path.values_mut() {
        metadata_indices.sort_by(|left, right| {
            let left = &symbol_metadata[*left];
            let right = &symbol_metadata[*right];
            left.line_start
                .cmp(&right.line_start)
                .then_with(|| left.byte_start.cmp(&right.byte_start))
                .then_with(|| right.line_end.cmp(&left.line_end))
                .then_with(|| right.byte_end.cmp(&left.byte_end))
                .then_with(|| left.name.cmp(&right.name))
        });
        let mut container_stack = Vec::<usize>::new();
        for metadata_index in metadata_indices {
            let metadata = &symbol_metadata[*metadata_index];
            while container_stack
                .last()
                .is_some_and(|ancestor| !symbol_contains(&symbol_metadata[*ancestor], metadata))
            {
                container_stack.pop();
            }
            let mut segments = container_stack
                .iter()
                .map(|ancestor| symbol_metadata[*ancestor].name.clone())
                .collect::<Vec<_>>();
            segments.push(metadata.name.clone());
            if metadata.explicit_segments.len() > segments.len() {
                segments = metadata.explicit_segments.clone();
            }
            symbols[metadata.index].qualified_name =
                format!("{}::{}", metadata.prefix, segments.join("."));
            symbols[metadata.index].canonical_symbol_id = format!(
                "repo://{repository_id}/{}",
                symbols[metadata.index].qualified_name
            );
            if container_kind(&metadata.kind) {
                container_stack.push(*metadata_index);
            }
        }
    }
}

struct SymbolIdentityMetadata {
    index: usize,
    path: String,
    name: String,
    kind: String,
    line_start: u32,
    line_end: u32,
    byte_start: u32,
    byte_end: u32,
    prefix: String,
    explicit_segments: Vec<String>,
}

fn path_prefix(qualified_name: &str) -> &str {
    qualified_name
        .rsplit_once("::")
        .map_or(qualified_name, |(prefix, _)| prefix)
}

fn explicit_qualified_segments(qualified_name: &str, name: &str) -> Vec<String> {
    let suffix = qualified_name
        .rsplit_once("::")
        .map_or(qualified_name, |(_, suffix)| suffix);
    let segments = suffix
        .split('.')
        .filter(|segment| !segment.is_empty())
        .map(ToOwned::to_owned)
        .collect::<Vec<_>>();
    if segments.last().is_some_and(|segment| segment == name) {
        segments
    } else {
        vec![name.to_owned()]
    }
}

fn container_kind(kind: &str) -> bool {
    matches!(
        kind,
        "class" | "constructor" | "function" | "interface" | "method" | "module" | "type"
    )
}

fn symbol_contains(container: &SymbolIdentityMetadata, symbol: &SymbolIdentityMetadata) -> bool {
    container.line_start <= symbol.line_start
        && container.line_end >= symbol.line_end
        && container.byte_start <= symbol.byte_start
        && container.byte_end >= symbol.byte_end
}