Skip to main content

work_graph/
emit.rs

1//! N-Quads + compact JSON emit. No Host invent; symbols stay Present-only.
2
3use 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
14/// Writes emit.
15pub 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
27/// Converts to nquads.
28pub 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
136/// JSON form.
137pub 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}