tiny.smg.analysis

1pub const DeltaFilter = struct {2    git_ref: []const u8,3    names: []const []const u8,4};

1pub fn overview(allocator: std.mem.Allocator, graph: graph_mod.Graph, top: i64, json: bool) ![]const u8 {2    const connected = try connectedRows(allocator, graph);3    const modules = try moduleRows(allocator, graph);4    const connected_display = paging.sliceEnd(connected.len, top);5    const module_display = paging.sliceEnd(modules.len, top);6    if (json) {7        var out: std.Io.Writer.Allocating = .init(allocator);8        errdefer out.deinit();9        var writer = pretty_json.Writer.init(&out.writer, .minified);10        try writer.beginObject();11        try writer.objectField("nodes");12        try writer.write(graph.nodes.items.len);13        try writer.objectField("edges");14        try writer.write(graph.edges.items.len);15        try writer.objectField("top_connected_basis");16        try writer.write("architecture_coupling");17        try writer.objectField("top_connected");18        try writer.beginArray();19        for (connected[0..connected_display]) |entry| {20            try writer.beginObject();21            try writer.objectField("name");22            try writer.write(entry.name);23            try writer.objectField("type");24            try writer.write(entry.type);25            try writer.objectField("incoming");26            try writer.write(entry.incoming);27            try writer.objectField("outgoing");28            try writer.write(entry.outgoing);29            try writer.objectField("total");30            try writer.write(entry.total);31            try writer.endObject();32        }33        try writer.endArray();34        try writer.objectField("modules");35        try writer.beginArray();36        for (modules) |entry| {37            try writer.beginObject();38            try writer.objectField("name");39            try writer.write(entry.name);40            try writer.objectField("type");41            try writer.write(entry.type);42            try writer.objectField("children");43            try writer.write(entry.children);44            try writer.endObject();45        }46        try writer.endArray();47        try writer.objectField("modules_basis");48        try writer.write("direct_declarations");49        try writer.endObject();50        try out.writer.writeByte('\n');51        return try out.toOwnedSlice();52    }53    var out: std.Io.Writer.Allocating = .init(allocator);54    errdefer out.deinit();55    try out.writer.print("Full graph: {d} nodes, {d} edges\n\n", .{ graph.nodes.items.len, graph.edges.items.len });56    try out.writer.print("Architecture Coupling (top {d})\n", .{top});57    try writeConnectedTable(allocator, &out.writer, connected[0..connected_display]);58    if (module_display != 0) {59        try out.writer.writeByte('\n');60        try out.writer.print("Modules by Direct Declarations (top {d})\n", .{top});61        try writeModuleTable(allocator, &out.writer, modules[0..module_display], modules.len, top);62    }63    return try out.toOwnedSlice();64}

1pub fn analyze(allocator: std.mem.Allocator, graph: graph_mod.Graph, summary: bool, json: bool, top: i64, full: bool, scope_label: ?[]const u8, concept_analysis: ?concepts_mod.Analysis, root: ?[]const u8, churn_days: i64, include_betweenness: bool, delta_filter: ?DeltaFilter, limits: smg.AnalysisLimits) ![]const u8 {2    const include_full_metrics = !summary;3    if (json) return try analyzeJson(allocator, graph, top, !full, include_full_metrics, concept_analysis, root, churn_days, include_betweenness, delta_filter, limits);4    return try analyzeText(allocator, graph, top, !full, !summary, scope_label, concept_analysis, root, churn_days, include_betweenness, delta_filter, limits);5}

1pub fn classMetricValue(allocator: std.mem.Allocator, graph: graph_mod.Graph, class_name: []const u8, metric_name: []const u8) !?f64 {2    const metrics = try classMetrics(allocator, graph, true);3    for (metrics) |metric| {4        if (!std.mem.eql(u8, metric.name, class_name)) continue;5        if (std.mem.eql(u8, metric_name, "wmc")) return @floatFromInt(metric.wmc);6        if (std.mem.eql(u8, metric_name, "cbo")) return @floatFromInt(metric.cbo);7        if (std.mem.eql(u8, metric_name, "rfc")) return @floatFromInt(metric.rfc);8        if (std.mem.eql(u8, metric_name, "lcom4")) return @floatFromInt(metric.lcom4);9        if (std.mem.eql(u8, metric_name, "dit")) return @floatFromInt(metric.dit);10        if (std.mem.eql(u8, metric_name, "noc")) return @floatFromInt(metric.noc);11        if (std.mem.eql(u8, metric_name, "max_method_cc")) return @floatFromInt(metric.max_method_cc);12        return null;13    }14    return null;15}

1pub fn moduleMetricValue(allocator: std.mem.Allocator, graph: graph_mod.Graph, module_name: []const u8, metric_name: []const u8) !?f64 {2    const metrics = try martinMetrics(allocator, graph);3    const metric = moduleMetricFor(metrics, module_name) orelse return null;4    if (std.mem.eql(u8, metric_name, "instability")) return metric.instability;5    if (std.mem.eql(u8, metric_name, "abstractness")) return metric.abstractness;6    if (std.mem.eql(u8, metric_name, "distance")) return metric.distance;7    return null;8}

1pub fn totalMetricBool(allocator: std.mem.Allocator, graph: graph_mod.Graph, name: []const u8, metric_name: []const u8) !?bool {2    if (std.mem.eql(u8, metric_name, "dead")) return containsString(try deadCodeRows(allocator, graph), name);3    if (std.mem.eql(u8, metric_name, "in_cycle")) {4        for (try findCycles(allocator, graph)) |cycle| {5            if (containsString(cycle, name)) return true;6        }7        return false;8    }9    return null;10}

1pub fn totalMetricValue(allocator: std.mem.Allocator, graph: graph_mod.Graph, name: []const u8, metric_name: []const u8, limits: smg.AnalysisLimits) !?f64 {2    if (std.mem.eql(u8, metric_name, "fan_in") or std.mem.eql(u8, metric_name, "fan_out")) {3        const rows = try fanRows(allocator, graph);4        for (rows) |row| {5            if (!std.mem.eql(u8, row.name, name)) continue;6            return @floatFromInt(if (std.mem.eql(u8, metric_name, "fan_in")) row.fan_in else row.fan_out);7        }8        return 0;9    }10    if (std.mem.eql(u8, metric_name, "layer")) return @floatFromInt(layerValue(try topologicalLayers(allocator, graph), name) orelse 0);11    if (std.mem.eql(u8, metric_name, "pagerank")) return rankedValue(try pagerankRows(allocator, graph), name) orelse 0;12    if (std.mem.eql(u8, metric_name, "betweenness")) return rankedValue(try betweennessRows(allocator, graph, false, limits), name) orelse 0;13    if (std.mem.eql(u8, metric_name, "kcore")) {14        const rows = try kcoreRows(allocator, graph);15        for (rows) |row| if (std.mem.eql(u8, row.name, name)) return @floatFromInt(row.value);16        return 0;17    }18    return null;19}

1const overview_mod = @import("overview.zig");2const report = @import("report.zig");34pub const paging = @import("paging.zig");56pub const DeltaFilter = report.DeltaFilter;78pub const analyze = report.analyze;9pub const classMetricValue = report.classMetricValue;10pub const moduleMetricValue = report.moduleMetricValue;11pub const overview = overview_mod.overview;12pub const totalMetricBool = report.totalMetricBool;13pub const totalMetricValue = report.totalMetricValue;

1pub const analysis = @import("analysis/root.zig");