relay-knowledge 1.1.16

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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use crate::domain::CodeRepositoryRegistration;

use super::*;

#[test]
fn json_and_yaml_config_paths_preserve_array_shape() {
    let json = parse_source_snapshot(
        "config.json",
        br#"{"server":{"port":8080},"containers":[{"name":"app"},{"name":"sidecar"}]}"#,
    );
    assert_config_symbol(&json, "server.port");
    assert_config_symbol(&json, "containers[].name");
    assert_no_config_symbol(&json, "containers.name");

    let yaml = parse_source_snapshot(
        "config.yaml",
        b"containers:\n  - name: app\nserver:\n  port: 8080\n",
    );
    assert_config_symbol(&yaml, "containers[].name");
    assert_config_symbol(&yaml, "server.port");
    assert_no_config_symbol(&yaml, "containers.name");
}

#[test]
fn nested_sequence_config_paths_preserve_each_array_level() {
    let json = parse_source_snapshot(
        "matrix.json",
        br#"{"matrix":[[{"name":"app"}]],"plain":[{"name":"worker"}]}"#,
    );
    assert_config_symbol(&json, "matrix[][].name");
    assert_config_symbol(&json, "plain[].name");
    assert_no_config_symbol(&json, "matrix[].name");

    let yaml = parse_source_snapshot(
        "matrix.yaml",
        b"matrix:\n  - - name: app\nplain:\n  - name: worker\n",
    );
    assert_config_symbol(&yaml, "matrix[][].name");
    assert_config_symbol(&yaml, "plain[].name");
    assert_no_config_symbol(&yaml, "matrix[].name");
}

#[test]
fn heterogeneous_sequence_config_paths_follow_the_matched_branch() {
    let json = parse_source_snapshot(
        "heterogeneous.json",
        br#"{"items":[{"name":"flat"},[{"name":"nested"}]]}"#,
    );

    assert_config_symbol(&json, "items[].name");
    assert_config_symbol(&json, "items[][].name");

    let yaml = parse_source_snapshot(
        "heterogeneous.yaml",
        b"items:\n  - name: flat\n  - - name: nested\n",
    );
    assert_config_symbol(&yaml, "items[].name");
    assert_config_symbol(&yaml, "items[][].name");
}

#[test]
fn toml_and_ini_config_paths_include_sections() {
    let toml = parse_source_snapshot(
        "Cargo.toml",
        b"[package]\nname = \"relay-knowledge\"\n[package.metadata]\nowner = \"team\"\n[[bin]]\nname = \"relay-knowledge\"\n",
    );
    assert_section_symbol(&toml, "package");
    assert_config_symbol(&toml, "package.name");
    assert_section_symbol(&toml, "package.metadata");
    assert_config_symbol(&toml, "package.metadata.owner");
    assert_section_symbol(&toml, "bin[]");
    assert_config_symbol(&toml, "bin[].name");

    let ini = parse_source_snapshot(
        "settings.ini",
        b"[server]\nenabled=true\nport: 8080\n[server.tls]\ncert=server.pem\n",
    );
    assert_section_symbol(&ini, "server");
    assert_config_symbol(&ini, "server.enabled");
    assert_config_symbol(&ini, "server.port");
    assert_section_symbol(&ini, "server.tls");
    assert_config_symbol(&ini, "server.tls.cert");
}

#[test]
fn nested_toml_array_tables_preserve_parent_array_shape() {
    let toml = parse_source_snapshot(
        "nested.toml",
        b"[[fruits]]\nname = \"apple\"\n[[fruits.varieties]]\nname = \"gala\"\n",
    );

    assert_section_symbol(&toml, "fruits[]");
    assert_config_symbol(&toml, "fruits[].name");
    assert_section_symbol(&toml, "fruits[].varieties[]");
    assert_config_symbol(&toml, "fruits[].varieties[].name");
    assert_no_config_symbol(&toml, "fruits.varieties[].name");
}

fn assert_config_symbol(snapshot: &crate::domain::CodeIndexSnapshot, name: &str) {
    assert_symbol(snapshot, name, "config");
}

fn assert_section_symbol(snapshot: &crate::domain::CodeIndexSnapshot, name: &str) {
    assert_symbol(snapshot, name, "section");
}

fn assert_no_config_symbol(snapshot: &crate::domain::CodeIndexSnapshot, name: &str) {
    assert!(
        !snapshot
            .symbols
            .iter()
            .any(|symbol| symbol.name == name && symbol.kind == "config"),
        "config symbol {name} should not be indexed: {:?}",
        snapshot.symbols
    );
}

fn assert_symbol(snapshot: &crate::domain::CodeIndexSnapshot, name: &str, kind: &str) {
    assert!(
        snapshot
            .symbols
            .iter()
            .any(|symbol| symbol.name == name && symbol.kind == kind),
        "{kind} symbol {name} should be indexed: {:?}",
        snapshot.symbols
    );
}

fn parse_source_snapshot(path: &str, source: &[u8]) -> crate::domain::CodeIndexSnapshot {
    let registration =
        CodeRepositoryRegistration::new("repo", "alias", "/tmp/repo", Vec::new(), Vec::new())
            .expect("registration should validate");
    let mut build = SnapshotBuild::new(
        &registration,
        "commit".to_owned(),
        "tree".to_owned(),
        true,
        1,
        0,
    );

    parse_indexed_file(&mut build, path, source).expect("file should parse");

    build.finish()
}