srcgraph-core 0.1.0

Graph model, traits, and GraphML I/O shared by srcgraph metric crates
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 petgraph::Graph;
use std::collections::HashMap;

use crate::{ClassNode, EdgeType, MethodConnectivity};

/// Concrete directed graph loaded from a GraphML file.
pub type OwnedGraph = Graph<OwnedClassNode, EdgeType>;

/// A class node with all attributes from the GraphML schema.
///
/// Required fields (`id`, `name`, `namespace`, `lineCount`, `methodCount`) are always
/// present. Halstead and semantic-mode fields are optional — they are `None` when the
/// GraphML was exported in syntax-only mode.
#[derive(Debug, Clone)]
pub struct OwnedClassNode {
    /// Fully-qualified class name used as the GraphML node id.
    pub id: String,
    pub name: String,
    pub namespace: String,
    pub line_count: u32,
    pub method_count: u32,
    pub halstead_eta1: u32,
    pub halstead_eta2: u32,
    pub halstead_n1: u32,
    pub halstead_n2: u32,
    pub method_connectivity: Option<MethodConnectivity>,
    // Semantic-mode JSON blobs — stored as raw serde_json::Value for downstream metrics.
    pub method_fingerprints: Option<serde_json::Value>,
    pub method_tokens: Option<serde_json::Value>,
    pub call_sequences: Option<serde_json::Value>,
    pub cyclomatic_complexity: Option<serde_json::Value>,
    pub path_conditions: Option<serde_json::Value>,
    pub invariants: Option<serde_json::Value>,
    pub error_messages: Option<serde_json::Value>,
    pub magic_numbers: Option<serde_json::Value>,
    pub dead_code: Option<serde_json::Value>,
    pub tenant_branches: Option<serde_json::Value>,
    pub state_transitions: Option<serde_json::Value>,
}

impl OwnedClassNode {
    pub(crate) fn from_data(
        id: &str,
        data: &HashMap<String, String>,
    ) -> Result<Self, crate::graphml::Error> {
        use crate::graphml::Error;

        let require = |key: &str| -> Result<&str, Error> {
            data.get(key)
                .map(String::as_str)
                .ok_or_else(|| Error::MissingAttr(key.to_owned()))
        };
        let require_u32 = |key: &str| -> Result<u32, Error> {
            require(key)?
                .parse::<u32>()
                .map_err(|e| Error::ParseInt { key: key.to_owned(), source: e })
        };
        let opt_u32 = |key: &str| -> u32 {
            data.get(key).and_then(|s| s.parse().ok()).unwrap_or(0)
        };
        let opt_json = |key: &str| -> Result<Option<serde_json::Value>, Error> {
            data.get(key)
                .map(|s| {
                    serde_json::from_str(s)
                        .map_err(|e| Error::Json { key: key.to_owned(), source: e })
                })
                .transpose()
        };

        Ok(OwnedClassNode {
            id: id.to_owned(),
            name: require("name")?.to_owned(),
            namespace: require("namespace")?.to_owned(),
            line_count: require_u32("lineCount")?,
            method_count: require_u32("methodCount")?,
            halstead_eta1: opt_u32("halstead_eta1"),
            halstead_eta2: opt_u32("halstead_eta2"),
            halstead_n1: opt_u32("halstead_N1"),
            halstead_n2: opt_u32("halstead_N2"),
            method_connectivity: data
                .get("methodConnectivity")
                .map(|s| {
                    serde_json::from_str(s).map_err(|e| Error::Json {
                        key: "methodConnectivity".to_owned(),
                        source: e,
                    })
                })
                .transpose()?,
            method_fingerprints: opt_json("methodFingerprints")?,
            method_tokens: opt_json("methodTokens")?,
            call_sequences: opt_json("callSequences")?,
            cyclomatic_complexity: opt_json("cyclomaticComplexity")?,
            path_conditions: opt_json("pathConditions")?,
            invariants: opt_json("invariants")?,
            error_messages: opt_json("errorMessages")?,
            magic_numbers: opt_json("magicNumbers")?,
            dead_code: opt_json("deadCode")?,
            tenant_branches: opt_json("tenantBranches")?,
            state_transitions: opt_json("stateTransitions")?,
        })
    }
}

impl ClassNode for OwnedClassNode {
    fn id(&self) -> &str {
        &self.id
    }
    fn namespace(&self) -> &str {
        &self.namespace
    }
    fn line_count(&self) -> u32 {
        self.line_count
    }
    fn method_count(&self) -> u32 {
        self.method_count
    }
    fn method_connectivity(&self) -> Option<&MethodConnectivity> {
        self.method_connectivity.as_ref()
    }
    fn cyclomatic_complexity(&self) -> Option<&serde_json::Value> {
        self.cyclomatic_complexity.as_ref()
    }
    fn halstead_eta1(&self) -> u32 {
        self.halstead_eta1
    }
    fn halstead_eta2(&self) -> u32 {
        self.halstead_eta2
    }
    fn halstead_n1(&self) -> u32 {
        self.halstead_n1
    }
    fn halstead_n2(&self) -> u32 {
        self.halstead_n2
    }
    fn method_tokens(&self) -> Option<&serde_json::Value> {
        self.method_tokens.as_ref()
    }
    fn method_fingerprints(&self) -> Option<&serde_json::Value> {
        self.method_fingerprints.as_ref()
    }
    fn call_sequences(&self) -> Option<&serde_json::Value> {
        self.call_sequences.as_ref()
    }
}