tiny.smg.cli.json

1const std = @import("std");2const pretty_json = @import("pretty").json;34const smg = @import("../root.zig");5const facts = smg.cli.facts;6const output = smg.cli.output;7const model = smg.model;8const rules = smg.rules;910pub fn writeAbout(writer: *std.Io.Writer, node: model.Node, depth: usize, full: bool, coupling_only: bool, incoming_all: usize, outgoing_all: usize, incoming: []const model.Edge, outgoing: []const model.Edge, path: []const []const u8, neighbors: []const []const u8) !void {11    var out = pretty_json.Writer.init(writer, .minified);12    try out.beginObject();13    try out.objectField("node");14    try model.writeNodeDataJsonObject(node, &out);15    var incoming_display = incoming;16    var outgoing_display = outgoing;17    var neighbors_display = neighbors;18    if (!full) {19        if (incoming_display.len > 10) incoming_display = incoming_display[0..10];20        if (outgoing_display.len > 10) outgoing_display = outgoing_display[0..10];21        if (neighbors_display.len > 10) neighbors_display = neighbors_display[0..10];22    }23    if (depth >= 1) {24        try out.objectField("containment_path");25        try writeStringArrayValue(&out, path);26        try out.objectField("incoming");27        try out.beginArray();28        for (incoming_display) |edge| {29            try out.beginObject();30            try out.objectField("source");31            try out.write(edge.source);32            try out.objectField("rel");33            try out.write(edge.rel);34            try out.endObject();35        }36        try out.endArray();37        try out.objectField("outgoing");38        try out.beginArray();39        for (outgoing_display) |edge| {40            try out.beginObject();41            try out.objectField("target");42            try out.write(edge.target);43            try out.objectField("rel");44            try out.write(edge.rel);45            try out.endObject();46        }47        try out.endArray();48        try out.objectField("incoming_total");49        try out.write(incoming.len);50        try out.objectField("outgoing_total");51        try out.write(outgoing.len);52        const incoming_truncated = incoming.len - incoming_display.len;53        const outgoing_truncated = outgoing.len - outgoing_display.len;54        const neighbors_truncated = neighbors.len - neighbors_display.len;55        const edge_truncated = !full and (incoming_truncated != 0 or outgoing_truncated != 0);56        const neighbor_truncated = !full and depth >= 2 and neighbors_truncated != 0;57        if (edge_truncated) {58            try out.objectField("truncated");59            try out.beginObject();60            if (incoming_truncated != 0) {61                try out.objectField("incoming");62                try out.write(incoming_truncated);63            }64            if (outgoing_truncated != 0) {65                try out.objectField("outgoing");66                try out.write(outgoing_truncated);67            }68            if (neighbor_truncated) {69                try out.objectField("neighbors");70                try out.write(neighbors_truncated);71            }72            try out.endObject();73        }74        if (coupling_only) {75            try out.objectField("hidden_rels");76            try out.beginObject();77            try out.objectField("incoming");78            try out.write(incoming_all - incoming.len);79            try out.objectField("outgoing");80            try out.write(outgoing_all - outgoing.len);81            try out.endObject();82        }83        if (depth >= 2) {84            try out.objectField("neighbors");85            try writeStringArrayValue(&out, neighbors_display);86            try out.objectField("neighbors_total");87            try out.write(neighbors.len);88            if (neighbor_truncated and !edge_truncated) {89                try out.objectField("truncated");90                try out.beginObject();91                try out.objectField("neighbors");92                try out.write(neighbors_truncated);93                try out.endObject();94            }95        }96    }97    try out.endObject();98    try writer.writeByte('\n');99}100101pub fn writeImpact(writer: *std.Io.Writer, target: []const u8, names: []const []const u8, total: usize, limit: i64, coupling_only: bool) !void {102    var out = pretty_json.Writer.init(writer, .minified);103    try out.beginObject();104    try out.objectField("target");105    try out.write(target);106    try out.objectField("affected");107    try writeStringArrayValue(&out, names);108    try out.objectField("count");109    try out.write(total);110    try out.objectField("displayed");111    try out.write(names.len);112    try out.objectField("truncated");113    try out.write(names.len < total);114    try out.objectField("limit");115    try out.write(limit);116    try out.objectField("coupling_only");117    try out.write(coupling_only);118    try out.endObject();119    try writer.writeByte('\n');120}121122pub fn writeBetween(writer: *std.Io.Writer, source: []const u8, target: []const u8, path: ?[]const []const u8, direct: []const model.Edge) !void {123    var out = pretty_json.Writer.init(writer, .minified);124    try out.beginObject();125    try out.objectField("source");126    try out.write(source);127    try out.objectField("target");128    try out.write(target);129    try out.objectField("path");130    if (path) |items| {131        try writeStringArrayValue(&out, items);132    } else {133        try out.write(null);134    }135    try out.objectField("direct_edges");136    try out.beginArray();137    for (direct) |edge| {138        try out.beginObject();139        try out.objectField("source");140        try out.write(edge.source);141        try out.objectField("rel");142        try out.write(edge.rel);143        try out.objectField("target");144        try out.write(edge.target);145        try out.endObject();146    }147    try out.endArray();148    try out.endObject();149    try writer.writeByte('\n');150}151152pub fn stringArray(allocator: std.mem.Allocator, values: []const []const u8) !u8 {153    return try output.writeOut(try renderStringArray(allocator, values));154}155156pub fn renderStringArray(allocator: std.mem.Allocator, values: []const []const u8) ![]const u8 {157    var out: std.Io.Writer.Allocating = .init(allocator);158    errdefer out.deinit();159    var writer = pretty_json.Writer.init(&out.writer, .minified);160    try writeStringArrayValue(&writer, values);161    try out.writer.writeByte('\n');162    return try out.toOwnedSlice();163}164165pub fn edgeArray(allocator: std.mem.Allocator, edges: []const model.Edge) !u8 {166    return try output.writeOut(try renderEdgeArray(allocator, edges));167}168169pub fn renderEdgeArray(allocator: std.mem.Allocator, edges: []const model.Edge) ![]const u8 {170    var out: std.Io.Writer.Allocating = .init(allocator);171    errdefer out.deinit();172    var writer = pretty_json.Writer.init(&out.writer, .minified);173    try writer.beginArray();174    for (edges) |edge| try model.writeEdgeDataJsonObject(edge, &writer);175    try writer.endArray();176    try out.writer.writeByte('\n');177    return try out.toOwnedSlice();178}179180pub fn writeFinding(allocator: std.mem.Allocator, writer: *pretty_json.Writer, finding: rules.Finding) !void {181    try writer.beginObject();182    try writer.objectField("rule");183    try writer.write(finding.rule);184    try writer.objectField("type");185    try writer.write(finding.type);186    try writer.objectField("message");187    try writer.write(finding.message);188    try writer.objectField("witnesses");189    try writer.beginArray();190    if (finding.predicates.len != 0) {191        for (finding.predicates) |predicate| {192            try writer.beginObject();193            try writer.objectField("kind");194            try writer.write("predicate");195            try writer.objectField("subject");196            try writer.write(predicate.subject);197            try writer.objectField("assertion");198            try writer.write(predicate.assertion);199            try writer.objectField("facts");200            try writer.beginObject();201            for (predicate.facts) |fact| {202                try writer.objectField(fact.name);203                try writeFactValue(allocator, writer, fact.value);204            }205            try writer.endObject();206            try writer.endObject();207        }208    } else if (finding.edges.len != 0) {209        try writer.beginObject();210        try writer.objectField("kind");211        try writer.write("edge");212        try writer.objectField("edges");213        try writer.beginArray();214        for (finding.edges) |edge| {215            try writer.beginObject();216            try writer.objectField("source");217            try writer.write(edge.source);218            try writer.objectField("rel");219            try writer.write(edge.rel);220            try writer.objectField("target");221            try writer.write(edge.target);222            try writer.endObject();223        }224        try writer.endArray();225        try writer.endObject();226    } else if (finding.nodes.len != 0) {227        try writer.beginObject();228        try writer.objectField("kind");229        try writer.write("node");230        try writer.objectField("nodes");231        try writeStringArrayValue(writer, finding.nodes);232        try writer.endObject();233    }234    try writer.endArray();235    try writer.endObject();236}237238pub fn writeFactValue(allocator: std.mem.Allocator, writer: *pretty_json.Writer, value: rules.FactValue) !void {239    switch (value) {240        .number => |number| {241            if (number == @floor(number)) {242                try writer.write(@as(i64, @intFromFloat(number)));243            } else {244                try writer.write(number);245            }246        },247        .float_number => |number| {248            const raw = try facts.floatText(allocator, number);249            defer allocator.free(raw);250            try writer.raw(raw);251        },252        .boolean => |boolean| try writer.write(boolean),253    }254}255256pub fn writeStringArrayValue(writer: *pretty_json.Writer, values: []const []const u8) !void {257    try writer.beginArray();258    for (values) |value| try writer.write(value);259    try writer.endArray();260}261262test "about json preserves coupling contract" {263    var out: std.Io.Writer.Allocating = .init(std.testing.allocator);264    defer out.deinit();265    const node = model.Node{ .name = "app.main", .type = model.NodeType.function, .file = "src/app.py", .line = 1, .docstring = "main doc\nmore" };266    const incoming = [_]model.Edge{};267    const outgoing = [_]model.Edge{.{ .source = "app.main", .rel = model.RelType.calls, .target = "app.helper" }};268    const path = [_][]const u8{ "app", "app.main" };269    try writeAbout(&out.writer, node, 1, false, true, 1, 1, &incoming, &outgoing, &path, &.{});270    try std.testing.expectEqualStrings(271        \\{"node":{"name":"app.main","type":"function","file":"src/app.py","line":1,"docstring":"main doc\nmore"},"containment_path":["app","app.main"],"incoming":[],"outgoing":[{"target":"app.helper","rel":"calls"}],"incoming_total":0,"outgoing_total":1,"hidden_rels":{"incoming":1,"outgoing":0}}272        \\273    , out.written());274}275276test "impact and between json preserve command schemas" {277    var out: std.Io.Writer.Allocating = .init(std.testing.allocator);278    defer out.deinit();279    try writeImpact(&out.writer, "app.helper", &.{"app.main"}, 1, 20, true);280    const path = [_][]const u8{ "a", "b" };281    const direct = [_]model.Edge{.{ .source = "a", .rel = model.RelType.calls, .target = "b" }};282    try writeBetween(&out.writer, "a", "b", &path, &direct);283    try writeBetween(&out.writer, "a", "d", null, &.{});284    try std.testing.expectEqualStrings(285        "{\"target\":\"app.helper\",\"affected\":[\"app.main\"],\"count\":1,\"displayed\":1,\"truncated\":false,\"limit\":20,\"coupling_only\":true}\n" ++286            "{\"source\":\"a\",\"target\":\"b\",\"path\":[\"a\",\"b\"],\"direct_edges\":[{\"source\":\"a\",\"rel\":\"calls\",\"target\":\"b\"}]}\n" ++287            "{\"source\":\"a\",\"target\":\"d\",\"path\":null,\"direct_edges\":[]}\n",288        out.written(),289    );290}291292test "array renderers preserve minified newline output" {293    const allocator = std.testing.allocator;294    const strings = try renderStringArray(allocator, &.{ "a", "b" });295    defer allocator.free(strings);296    try std.testing.expectEqualStrings("[\"a\",\"b\"]\n", strings);297    const edges = [_]model.Edge{.{ .source = "a", .rel = model.RelType.calls, .target = "b" }};298    const edge_json = try renderEdgeArray(allocator, &edges);299    defer allocator.free(edge_json);300    try std.testing.expectEqualStrings("[{\"source\":\"a\",\"rel\":\"calls\",\"target\":\"b\"}]\n", edge_json);301}302303test "finding json preserves quantified predicate witness contract" {304    const allocator = std.testing.allocator;305    const fact = rules.PredicateFact{ .name = "fan_out", .value = .{ .number = 1 } };306    const predicate = rules.PredicateWitness{ .subject = "core.lib", .assertion = "fan_out <= 0", .facts = &.{fact} };307    const finding = rules.Finding{308        .rule = "fan-out",309        .type = "quantified",310        .message = "1 subject(s) failed fan_out <= 0",311        .nodes = &.{"core.lib"},312        .predicates = &.{predicate},313    };314    var out: std.Io.Writer.Allocating = .init(allocator);315    defer out.deinit();316    var writer = pretty_json.Writer.init(&out.writer, .minified);317    try writeFinding(allocator, &writer, finding);318    try std.testing.expectEqualStrings(319        \\{"rule":"fan-out","type":"quantified","message":"1 subject(s) failed fan_out <= 0","witnesses":[{"kind":"predicate","subject":"core.lib","assertion":"fan_out <= 0","facts":{"fan_out":1}}]}320    , out.written());321}

1pub const json = @import("json.zig");