the_code_graph_storage/
mapping.rs

1use domain::error::{CodeGraphError, Result};
2use domain::model::*;
3
4pub(crate) fn map_rusqlite_error(e: rusqlite::Error) -> CodeGraphError {
5    CodeGraphError::Storage(e.to_string())
6}
7
8// ---------------------------------------------------------------------------
9// Language
10// ---------------------------------------------------------------------------
11
12pub(crate) fn language_to_str(l: &Language) -> &'static str {
13    match l {
14        Language::TypeScript => "TypeScript",
15        Language::JavaScript => "JavaScript",
16        Language::Rust => "Rust",
17        Language::Python => "Python",
18        Language::Go => "Go",
19    }
20}
21
22pub(crate) fn language_from_str(s: &str) -> Result<Language> {
23    match s {
24        "TypeScript" => Ok(Language::TypeScript),
25        "JavaScript" => Ok(Language::JavaScript),
26        "Rust" => Ok(Language::Rust),
27        "Python" => Ok(Language::Python),
28        "Go" => Ok(Language::Go),
29        _ => Err(CodeGraphError::Storage(format!("unknown language: {s}"))),
30    }
31}
32
33// ---------------------------------------------------------------------------
34// SymbolKind
35// ---------------------------------------------------------------------------
36
37pub(crate) fn symbol_kind_to_str(k: &SymbolKind) -> &'static str {
38    match k {
39        SymbolKind::Function => "function",
40        SymbolKind::Class => "class",
41        SymbolKind::Interface => "interface",
42        SymbolKind::Struct => "struct",
43        SymbolKind::Trait => "trait",
44        SymbolKind::Enum => "enum",
45        SymbolKind::TypeAlias => "type_alias",
46        SymbolKind::Method => "method",
47        SymbolKind::Property => "property",
48        SymbolKind::Const => "const",
49        SymbolKind::Macro => "macro",
50        SymbolKind::Variable => "variable",
51        SymbolKind::Component => "component",
52        SymbolKind::Test => "test",
53    }
54}
55
56pub(crate) fn symbol_kind_from_str(s: &str) -> Result<SymbolKind> {
57    match s {
58        "function" => Ok(SymbolKind::Function),
59        "class" => Ok(SymbolKind::Class),
60        "interface" => Ok(SymbolKind::Interface),
61        "struct" => Ok(SymbolKind::Struct),
62        "trait" => Ok(SymbolKind::Trait),
63        "enum" => Ok(SymbolKind::Enum),
64        "type_alias" => Ok(SymbolKind::TypeAlias),
65        "method" => Ok(SymbolKind::Method),
66        "property" => Ok(SymbolKind::Property),
67        "const" => Ok(SymbolKind::Const),
68        "macro" => Ok(SymbolKind::Macro),
69        "variable" => Ok(SymbolKind::Variable),
70        "component" => Ok(SymbolKind::Component),
71        "test" => Ok(SymbolKind::Test),
72        _ => Err(CodeGraphError::Storage(format!("unknown symbol kind: {s}"))),
73    }
74}
75
76// ---------------------------------------------------------------------------
77// EdgeKind
78// ---------------------------------------------------------------------------
79
80pub(crate) fn edge_kind_to_str(k: &EdgeKind) -> &'static str {
81    match k {
82        EdgeKind::Contains => "contains",
83        EdgeKind::ChildOf => "child_of",
84        EdgeKind::Calls => "calls",
85        EdgeKind::ImportsFrom => "imports_from",
86        EdgeKind::Extends => "extends",
87        EdgeKind::Implements => "implements",
88        EdgeKind::TestedBy => "tested_by",
89        EdgeKind::DependsOn => "depends_on",
90        EdgeKind::BarrelReExportAll => "barrel_re_export_all",
91        EdgeKind::ConditionalImport => "conditional_import",
92        EdgeKind::SideEffectImport => "side_effect_import",
93        EdgeKind::DotImport => "dot_import",
94        EdgeKind::HasDecorator => "has_decorator",
95        EdgeKind::Embeds => "embeds",
96        EdgeKind::TypeReference => "type_reference",
97        EdgeKind::ReExport => "re_export",
98    }
99}
100
101pub(crate) fn edge_kind_from_str(s: &str) -> Result<EdgeKind> {
102    match s {
103        "contains" => Ok(EdgeKind::Contains),
104        "child_of" => Ok(EdgeKind::ChildOf),
105        "calls" => Ok(EdgeKind::Calls),
106        "imports_from" => Ok(EdgeKind::ImportsFrom),
107        "extends" => Ok(EdgeKind::Extends),
108        "implements" => Ok(EdgeKind::Implements),
109        "tested_by" => Ok(EdgeKind::TestedBy),
110        "depends_on" => Ok(EdgeKind::DependsOn),
111        "barrel_re_export_all" => Ok(EdgeKind::BarrelReExportAll),
112        "conditional_import" => Ok(EdgeKind::ConditionalImport),
113        "side_effect_import" => Ok(EdgeKind::SideEffectImport),
114        "dot_import" => Ok(EdgeKind::DotImport),
115        "has_decorator" => Ok(EdgeKind::HasDecorator),
116        "embeds" => Ok(EdgeKind::Embeds),
117        "type_reference" => Ok(EdgeKind::TypeReference),
118        "re_export" => Ok(EdgeKind::ReExport),
119        _ => Err(CodeGraphError::Storage(format!("unknown edge kind: {s}"))),
120    }
121}
122
123// ---------------------------------------------------------------------------
124// Visibility
125// ---------------------------------------------------------------------------
126
127pub(crate) fn visibility_to_str(v: &Visibility) -> &'static str {
128    match v {
129        Visibility::Public => "public",
130        Visibility::Private => "private",
131        Visibility::Crate => "crate",
132    }
133}
134
135pub(crate) fn visibility_from_str(s: &str) -> Result<Visibility> {
136    match s {
137        "public" => Ok(Visibility::Public),
138        "private" => Ok(Visibility::Private),
139        "crate" => Ok(Visibility::Crate),
140        _ => Err(CodeGraphError::Storage(format!("unknown visibility: {s}"))),
141    }
142}
143
144// ---------------------------------------------------------------------------
145// NonParsedKind
146// ---------------------------------------------------------------------------
147
148#[allow(dead_code)]
149pub(crate) fn non_parsed_kind_to_str(k: &NonParsedKind) -> &'static str {
150    match k {
151        NonParsedKind::Doc => "doc",
152        NonParsedKind::Config => "config",
153        NonParsedKind::CI => "ci",
154        NonParsedKind::Asset => "asset",
155        NonParsedKind::Other => "other",
156    }
157}
158
159#[allow(dead_code)]
160pub(crate) fn non_parsed_kind_from_str(s: &str) -> Result<NonParsedKind> {
161    match s {
162        "doc" => Ok(NonParsedKind::Doc),
163        "config" => Ok(NonParsedKind::Config),
164        "ci" => Ok(NonParsedKind::CI),
165        "asset" => Ok(NonParsedKind::Asset),
166        "other" => Ok(NonParsedKind::Other),
167        _ => Err(CodeGraphError::Storage(format!(
168            "unknown non-parsed kind: {s}"
169        ))),
170    }
171}
172
173#[cfg(test)]
174mod tests {
175    use super::*;
176
177    #[test]
178    fn language_roundtrip_all_variants() {
179        let variants = [
180            Language::TypeScript,
181            Language::JavaScript,
182            Language::Rust,
183            Language::Python,
184            Language::Go,
185        ];
186        for v in &variants {
187            let s = language_to_str(v);
188            let back = language_from_str(s).unwrap();
189            assert_eq!(*v, back, "roundtrip failed for {s}");
190        }
191    }
192
193    #[test]
194    fn symbol_kind_roundtrip_all_variants() {
195        let variants = [
196            SymbolKind::Function,
197            SymbolKind::Class,
198            SymbolKind::Interface,
199            SymbolKind::Struct,
200            SymbolKind::Trait,
201            SymbolKind::Enum,
202            SymbolKind::TypeAlias,
203            SymbolKind::Method,
204            SymbolKind::Property,
205            SymbolKind::Const,
206            SymbolKind::Macro,
207            SymbolKind::Variable,
208            SymbolKind::Component,
209            SymbolKind::Test,
210        ];
211        for v in &variants {
212            let s = symbol_kind_to_str(v);
213            let back = symbol_kind_from_str(s).unwrap();
214            assert_eq!(*v, back, "roundtrip failed for {s}");
215        }
216    }
217
218    #[test]
219    fn edge_kind_roundtrip_all_16_variants() {
220        let variants = [
221            EdgeKind::Contains,
222            EdgeKind::ChildOf,
223            EdgeKind::Calls,
224            EdgeKind::ImportsFrom,
225            EdgeKind::Extends,
226            EdgeKind::Implements,
227            EdgeKind::TestedBy,
228            EdgeKind::DependsOn,
229            EdgeKind::BarrelReExportAll,
230            EdgeKind::ConditionalImport,
231            EdgeKind::SideEffectImport,
232            EdgeKind::DotImport,
233            EdgeKind::HasDecorator,
234            EdgeKind::Embeds,
235            EdgeKind::TypeReference,
236            EdgeKind::ReExport,
237        ];
238        assert_eq!(variants.len(), 16);
239        for v in &variants {
240            let s = edge_kind_to_str(v);
241            let back = edge_kind_from_str(s).unwrap();
242            assert_eq!(*v, back, "roundtrip failed for {s}");
243        }
244    }
245
246    #[test]
247    fn visibility_roundtrip_all_variants() {
248        for v in &[Visibility::Public, Visibility::Private, Visibility::Crate] {
249            let s = visibility_to_str(v);
250            let back = visibility_from_str(s).unwrap();
251            assert_eq!(*v, back);
252        }
253    }
254
255    #[test]
256    fn non_parsed_kind_roundtrip_all_variants() {
257        let variants = [
258            NonParsedKind::Doc,
259            NonParsedKind::Config,
260            NonParsedKind::CI,
261            NonParsedKind::Asset,
262            NonParsedKind::Other,
263        ];
264        for v in &variants {
265            let s = non_parsed_kind_to_str(v);
266            let back = non_parsed_kind_from_str(s).unwrap();
267            assert_eq!(*v, back);
268        }
269    }
270
271    #[test]
272    fn unknown_string_returns_storage_error() {
273        assert!(language_from_str("Haskell").is_err());
274        assert!(symbol_kind_from_str("Widget").is_err());
275        assert!(edge_kind_from_str("MagicLink").is_err());
276        assert!(visibility_from_str("Protected").is_err());
277        assert!(non_parsed_kind_from_str("Unknown").is_err());
278    }
279}
the_code_graph_storage/mapping.rs

the_code_graph_storage/
mapping.rs
