relay-knowledge 1.1.9

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

#[derive(Default)]
pub(in crate::code::config_files) struct BlockScalarTracker {
    parent_indent: Option<usize>,
}

impl BlockScalarTracker {
    pub(in crate::code::config_files) fn should_skip(&mut self, line: &str, trimmed: &str) -> bool {
        if trimmed.is_empty() {
            return self.parent_indent.is_some();
        }

        let indent = line.len() - line.trim_start().len();
        if let Some(parent_indent) = self.parent_indent {
            if indent > parent_indent {
                return true;
            }
            self.parent_indent = None;
        }

        if block_scalar_starts(trimmed) {
            self.parent_indent = Some(indent);
        }
        false
    }
}

fn block_scalar_starts(trimmed: &str) -> bool {
    let marker = if let Some((_, value)) = trimmed.split_once(':') {
        value
    } else {
        trimmed.strip_prefix('-').map(str::trim_start).unwrap_or("")
    };
    let marker = marker.split('#').next().unwrap_or(marker).trim();
    let Some(first) = marker.chars().next() else {
        return false;
    };
    matches!(first, '|' | '>')
        && marker[1..]
            .chars()
            .all(|character| matches!(character, '+' | '-') || character.is_ascii_digit())
}

pub(in crate::code::config_files) fn mapping_key(trimmed: &str) -> Option<&str> {
    let candidate = trimmed
        .strip_prefix('-')
        .map(str::trim_start)
        .unwrap_or(trimmed);
    let separator = mapping_separator(candidate)?;

    Some(&candidate[..separator])
}

fn mapping_separator(value: &str) -> Option<usize> {
    let mut index = 0;
    let mut quote = None;
    let mut escaped = false;
    while index < value.len() {
        let rest = &value[index..];
        let character = rest
            .chars()
            .next()
            .expect("index should point to a character boundary");
        if escaped {
            escaped = false;
            index += character.len_utf8();
            continue;
        }
        if quote == Some('"') && character == '\\' {
            escaped = true;
            index += character.len_utf8();
            continue;
        }
        if quote == Some('\'') && rest.starts_with("''") {
            index += "''".len();
            continue;
        }
        if matches!(character, '"' | '\'') {
            if quote == Some(character) {
                quote = None;
            } else if quote.is_none() {
                quote = Some(character);
            }
            index += character.len_utf8();
            continue;
        }
        if character == ':' && quote.is_none() {
            let after = &value[index + ':'.len_utf8()..];
            if after.chars().next().is_none_or(char::is_whitespace) {
                return Some(index);
            }
        }
        index += character.len_utf8();
    }

    None
}