1use std::fs;
4use std::io::{self, Write};
5use std::path::Path;
6
7use crate::model::WorkGraph;
8
9pub const NS: &str = "https://webizen.org/ns/work-graph#";
10pub const RDF_TYPE: &str = "<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>";
11pub const NQ_NAME: &str = "impl-graph.nq";
12pub const JSON_NAME: &str = "impl-graph.json";
13
14pub fn write_emit(
16 graph: &WorkGraph,
17 out_dir: &Path,
18) -> io::Result<(std::path::PathBuf, std::path::PathBuf)> {
19 fs::create_dir_all(out_dir)?;
20 let nq_path = out_dir.join(NQ_NAME);
21 let json_path = out_dir.join(JSON_NAME);
22 fs::write(&nq_path, to_nquads(graph))?;
23 fs::write(&json_path, to_json(graph))?;
24 Ok((nq_path, json_path))
25}
26
27pub fn to_nquads(graph: &WorkGraph) -> String {
29 let mut out = String::new();
30 let project = iri("project");
31 triple(&mut out, &project, RDF_TYPE, &iri("Project"));
32 lit(&mut out, &project, &pred("root"), &graph.project.root);
33 lit(&mut out, &project, &pred("tipSha"), &graph.project.tip_sha);
34 lit(&mut out, &project, &pred("branch"), &graph.project.branch);
35 lit(
36 &mut out,
37 &project,
38 &pred("dirty"),
39 if graph.project.dirty { "true" } else { "false" },
40 );
41 lit(
42 &mut out,
43 &project,
44 &pred("indexedAt"),
45 &graph.project.indexed_at_unix.to_string(),
46 );
47 lit(
48 &mut out,
49 &project,
50 &pred("emitHonesty"),
51 graph.honesty.this_emit,
52 );
53 lit(&mut out, &project, &pred("customerName"), "Work graph");
54 lit(
55 &mut out,
56 &project,
57 &pred("allBoundSource"),
58 &graph.sources.all_bound,
59 );
60 if let Some(cat) = &graph.sources.catalog {
61 lit(&mut out, &project, &pred("catalogSource"), cat);
62 }
63
64 for file in &graph.files {
65 let s = file_iri(&file.path);
66 triple(&mut out, &s, RDF_TYPE, &iri("File"));
67 lit(&mut out, &s, &pred("path"), &file.path);
68 lit(&mut out, &s, &pred("lang"), file.lang);
69 triple(&mut out, &s, &pred("inProject"), &project);
70 }
71
72 for krate in &graph.crates {
73 let s = crate_iri(&krate.name);
74 triple(&mut out, &s, RDF_TYPE, &iri("Crate"));
75 lit(&mut out, &s, &pred("name"), &krate.name);
76 triple(&mut out, &s, &pred("inFile"), &file_iri(&krate.manifest));
77 triple(&mut out, &s, &pred("inProject"), &project);
78 }
79
80 let catalog: std::collections::BTreeSet<&str> =
81 graph.catalog_ids.iter().map(String::as_str).collect();
82
83 for id in &graph.invoke_ids {
84 let s = invoke_iri(id);
85 triple(&mut out, &s, RDF_TYPE, &iri("InvokeId"));
86 lit(&mut out, &s, &pred("id"), id);
87 if let Some(fam) = crate::extract::family_of(id) {
88 triple(&mut out, &s, &pred("inFamily"), &family_iri(fam));
89 }
90 triple(
91 &mut out,
92 &s,
93 &pred("inFile"),
94 &file_iri(&graph.sources.all_bound),
95 );
96 if catalog.contains(id.as_str()) {
97 triple(&mut out, &s, &pred("catalogMember"), &iri("vibeCatalog"));
98 }
99 triple(&mut out, &s, &pred("inProject"), &project);
100 }
101
102 for fam in &graph.families {
103 let s = family_iri(&fam.name);
104 triple(&mut out, &s, RDF_TYPE, &iri("Family"));
105 lit(&mut out, &s, &pred("name"), &fam.name);
106 lit(
107 &mut out,
108 &s,
109 &pred("memberCount"),
110 &fam.member_count.to_string(),
111 );
112 triple(&mut out, &s, &pred("inProject"), &project);
113 }
114
115 for path in &graph.doc_pages {
116 let s = doc_iri(path);
117 triple(&mut out, &s, RDF_TYPE, &iri("DocPage"));
118 lit(&mut out, &s, &pred("path"), path);
119 triple(&mut out, &s, &pred("inFile"), &file_iri(path));
120 triple(&mut out, &s, &pred("inProject"), &project);
121 }
122
123 for cite in &graph.doc_cites {
124 let doc = doc_iri(&cite.doc_path);
125 let about = if cite.kind == "family" {
126 family_iri(&cite.about)
127 } else {
128 invoke_iri(&cite.about)
129 };
130 triple(&mut out, &about, &pred("documentedBy"), &doc);
131 }
132
133 out
134}
135
136pub fn to_json(graph: &WorkGraph) -> String {
138 let mut w = Vec::new();
139 let _ = write_json(&mut w, graph);
140 String::from_utf8(w).unwrap_or_else(|_| "{}".into())
141}
142
143fn write_json(w: &mut Vec<u8>, graph: &WorkGraph) -> io::Result<()> {
144 write!(w, "{{\n")?;
145 write!(w, " \"customerName\": \"Work graph\",\n")?;
146 write!(w, " \"workingId\": \"implementation-graph\",\n")?;
147 write!(w, " \"noHostInvent\": true,\n")?;
148 write!(w, " \"honesty\": {{\n")?;
149 write!(
150 w,
151 " \"vocabulary\": [\"Present\", \"Live\", \"Planned\"],\n"
152 )?;
153 write!(w, " \"thisEmit\": \"Present\",\n")?;
154 write!(w, " \"note\": {}\n", json_str(graph.honesty.note))?;
155 write!(w, " }},\n")?;
156 write!(w, " \"project\": {{\n")?;
157 write!(w, " \"root\": {},\n", json_str(&graph.project.root))?;
158 write!(w, " \"tipSha\": {},\n", json_str(&graph.project.tip_sha))?;
159 write!(w, " \"branch\": {},\n", json_str(&graph.project.branch))?;
160 write!(w, " \"dirty\": {},\n", graph.project.dirty)?;
161 write!(
162 w,
163 " \"indexedAtUnix\": {}\n",
164 graph.project.indexed_at_unix
165 )?;
166 write!(w, " }},\n")?;
167 write!(w, " \"sources\": {{\n")?;
168 write!(
169 w,
170 " \"allBound\": {},\n",
171 json_str(&graph.sources.all_bound)
172 )?;
173 match &graph.sources.catalog {
174 Some(c) => write!(w, " \"catalog\": {}\n", json_str(c))?,
175 None => write!(w, " \"catalog\": null\n")?,
176 }
177 write!(w, " }},\n")?;
178 write!(w, " \"counts\": {{\n")?;
179 write!(w, " \"files\": {},\n", graph.files.len())?;
180 write!(w, " \"crates\": {},\n", graph.crates.len())?;
181 write!(w, " \"invokeIds\": {},\n", graph.invoke_ids.len())?;
182 write!(w, " \"catalogIds\": {},\n", graph.catalog_ids.len())?;
183 write!(w, " \"families\": {},\n", graph.families.len())?;
184 write!(w, " \"docPages\": {},\n", graph.doc_pages.len())?;
185 write!(w, " \"docCites\": {}\n", graph.doc_cites.len())?;
186 write!(w, " }},\n")?;
187 write!(w, " \"crates\": [")?;
188 for (i, k) in graph.crates.iter().enumerate() {
189 if i > 0 {
190 write!(w, ", ")?;
191 }
192 write!(w, "{}", json_str(&k.name))?;
193 }
194 write!(w, "],\n")?;
195 write!(w, " \"families\": [\n")?;
196 for (i, fam) in graph.families.iter().enumerate() {
197 if i > 0 {
198 write!(w, ",\n")?;
199 }
200 write!(
201 w,
202 " {{\"name\": {}, \"memberCount\": {}}}",
203 json_str(&fam.name),
204 fam.member_count
205 )?;
206 }
207 write!(w, "\n ],\n")?;
208 write!(w, " \"invokeIds\": [\n")?;
209 for (i, id) in graph.invoke_ids.iter().enumerate() {
210 if i > 0 {
211 write!(w, ",\n")?;
212 }
213 write!(w, " {}", json_str(id))?;
214 }
215 write!(w, "\n ],\n")?;
216 let missing_cat = graph.bound_missing_from_catalog();
217 let extra_cat = graph.catalog_only_ids();
218 write!(w, " \"boundMissingFromCatalog\": [")?;
219 for (i, id) in missing_cat.iter().enumerate() {
220 if i > 0 {
221 write!(w, ", ")?;
222 }
223 write!(w, "{}", json_str(id))?;
224 }
225 write!(w, "],\n")?;
226 write!(w, " \"catalogOnlyIds\": [")?;
227 for (i, id) in extra_cat.iter().enumerate() {
228 if i > 0 {
229 write!(w, ", ")?;
230 }
231 write!(w, "{}", json_str(id))?;
232 }
233 write!(w, "],\n")?;
234 write!(w, " \"docCites\": [\n")?;
235 for (i, cite) in graph.doc_cites.iter().enumerate() {
236 if i > 0 {
237 write!(w, ",\n")?;
238 }
239 write!(
240 w,
241 " {{\"about\": {}, \"doc\": {}, \"kind\": {}}}",
242 json_str(&cite.about),
243 json_str(&cite.doc_path),
244 json_str(cite.kind)
245 )?;
246 }
247 write!(w, "\n ]\n")?;
248 write!(w, "}}\n")?;
249 Ok(())
250}
251
252fn iri(local: &str) -> String {
253 format!("<{NS}{local}>")
254}
255
256fn pred(name: &str) -> String {
257 iri(name)
258}
259
260fn file_iri(path: &str) -> String {
261 iri(&format!("file/{}", encode_seg(path)))
262}
263
264fn crate_iri(name: &str) -> String {
265 iri(&format!("crate/{}", encode_seg(name)))
266}
267
268fn invoke_iri(id: &str) -> String {
269 iri(&format!("invoke/{}", encode_seg(id)))
270}
271
272fn family_iri(name: &str) -> String {
273 iri(&format!("family/{}", encode_seg(name)))
274}
275
276fn doc_iri(path: &str) -> String {
277 iri(&format!("doc/{}", encode_seg(path)))
278}
279
280fn triple(out: &mut String, s: &str, p: &str, o: &str) {
281 out.push_str(s);
282 out.push(' ');
283 out.push_str(p);
284 out.push(' ');
285 out.push_str(o);
286 out.push_str(" .\n");
287}
288
289fn lit(out: &mut String, s: &str, p: &str, value: &str) {
290 out.push_str(s);
291 out.push(' ');
292 out.push_str(p);
293 out.push(' ');
294 out.push_str(&nq_string(value));
295 out.push_str(" .\n");
296}
297
298fn nq_string(value: &str) -> String {
299 let mut s = String::from("\"");
300 for c in value.chars() {
301 match c {
302 '\\' => s.push_str("\\\\"),
303 '"' => s.push_str("\\\""),
304 '\n' => s.push_str("\\n"),
305 '\r' => s.push_str("\\r"),
306 _ => s.push(c),
307 }
308 }
309 s.push('"');
310 s
311}
312
313fn json_str(value: &str) -> String {
314 let mut s = String::from("\"");
315 for c in value.chars() {
316 match c {
317 '\\' => s.push_str("\\\\"),
318 '"' => s.push_str("\\\""),
319 '\n' => s.push_str("\\n"),
320 '\r' => s.push_str("\\r"),
321 '\t' => s.push_str("\\t"),
322 c if c.is_control() => s.push_str(&format!("\\u{:04x}", c as u32)),
323 _ => s.push(c),
324 }
325 }
326 s.push('"');
327 s
328}
329
330fn encode_seg(path: &str) -> String {
331 let mut out = String::new();
332 for b in path.bytes() {
333 match b {
334 b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' | b'/' => {
335 out.push(b as char);
336 }
337 _ => out.push_str(&format!("%{b:02X}")),
338 }
339 }
340 out
341}
342
343#[cfg(test)]
344mod tests {
345 use super::*;
346 use crate::model::{
347 CrateNode, DocCite, FamilyNode, FileNode, Honesty, Project, Sources, WorkGraph,
348 };
349
350 fn sample() -> WorkGraph {
351 WorkGraph {
352 honesty: Honesty::presence_index(),
353 project: Project {
354 root: "/repo".into(),
355 tip_sha: "abc123".into(),
356 branch: "0.0.38".into(),
357 dirty: false,
358 indexed_at_unix: 1,
359 },
360 files: vec![FileNode {
361 path: "crates/vibe/Cargo.toml".into(),
362 lang: "toml",
363 }],
364 crates: vec![CrateNode {
365 name: "vibe".into(),
366 manifest: "crates/vibe/Cargo.toml".into(),
367 }],
368 invoke_ids: vec!["ClinicalRisk.framingham".into()],
369 catalog_ids: vec!["ClinicalRisk.framingham".into()],
370 catalog_present: true,
371 families: vec![FamilyNode {
372 name: "ClinicalRisk".into(),
373 member_count: 1,
374 }],
375 doc_pages: vec!["docs/vibe/SKILL.md".into()],
376 doc_cites: vec![DocCite {
377 about: "ClinicalRisk.framingham".into(),
378 doc_path: "docs/vibe/SKILL.md".into(),
379 kind: "invoke",
380 }],
381 sources: Sources {
382 all_bound: crate::ALL_BOUND_REL.into(),
383 catalog: Some(crate::CATALOG_REL.into()),
384 },
385 }
386 }
387
388 #[test]
389 fn nquads_has_tip_invoke_and_cite() {
390 let nq = to_nquads(&sample());
391 assert!(nq.contains("abc123"));
392 assert!(nq.contains("ClinicalRisk.framingham"));
393 assert!(nq.contains("documentedBy"));
394 assert!(nq.contains("emitHonesty"));
395 assert!(
396 nq.contains("<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>"),
397 "rdf:type must be an IRI in N-Quads"
398 );
399 assert!(!nq.contains("ImplGraph."));
400 assert!(!nq.contains("held"));
401 }
402
403 #[test]
404 fn json_is_presence_only() {
405 let js = to_json(&sample());
406 assert!(js.contains("\"thisEmit\": \"Present\""));
407 assert!(js.contains("\"noHostInvent\": true"));
408 assert!(js.contains("ClinicalRisk.framingham"));
409 assert!(!js.contains("ImplGraph."));
410 }
411}