gnosis 0.1.0

Gnosis — enterprise knowledge compiler (CLI + library)
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

use crate::{
    AttributeMap, Confidence, Entity, EntityId, Evidence, ObjectId, ProviderId, Relationship,
    RelationshipId, SourceSpan,
};
use std::collections::BTreeMap;
use std::path::Path;

pub fn evidence(
    provider: &ProviderId,
    summary: impl Into<String>,
    path: &Path,
    line: u32,
) -> Evidence {
    Evidence {
        summary: summary.into(),
        span: Some(SourceSpan::line(path.to_path_buf(), line)),
        provider: provider.clone(),
    }
}

pub fn entity(
    kind: &str,
    name: &str,
    path: &Path,
    source: &ObjectId,
    provider: &ProviderId,
    line: u32,
    attrs: AttributeMap,
    confidence: Confidence,
) -> Entity {
    let path_str = path.to_string_lossy();
    Entity {
        id: EntityId::generate(kind, name, &path_str),
        kind: kind.into(),
        name: name.into(),
        attributes: attrs,
        evidence: vec![evidence(provider, format!("{kind} {name}"), path, line)],
        confidence,
        source_object: source.clone(),
    }
}

pub fn relationship(
    kind: &str,
    from: &EntityId,
    to: &EntityId,
    provider: &ProviderId,
    path: &Path,
    line: u32,
    confidence: Confidence,
) -> Relationship {
    Relationship {
        id: RelationshipId::generate(kind, from.as_str(), to.as_str()),
        kind: kind.into(),
        from: from.clone(),
        to: to.clone(),
        attributes: BTreeMap::new(),
        evidence: vec![evidence(provider, kind, path, line)],
        confidence,
    }
}

pub fn attrs(pairs: &[(&str, &str)]) -> AttributeMap {
    pairs
        .iter()
        .map(|(k, v)| ((*k).to_string(), (*v).to_string()))
        .collect()
}

pub fn line_of(source: &str, byte_offset: usize) -> u32 {
    let mut line = 1u32;
    for (i, b) in source.bytes().enumerate() {
        if i >= byte_offset {
            break;
        }
        if b == b'\n' {
            line += 1;
        }
    }
    line
}

pub fn ext_is(object_ext: &Option<String>, candidates: &[&str]) -> bool {
    object_ext
        .as_ref()
        .map(|e| candidates.iter().any(|c| e.eq_ignore_ascii_case(c)))
        .unwrap_or(false)
}