tiny.smg.command.check

1pub fn failed(findings: []const rules.Finding, dead: []const rules.DeadRule) bool {2    return findings.len != 0 or dead.len != 0;3}

1pub fn writeJson(allocator: std.mem.Allocator, writer: *std.Io.Writer, rules_checked: usize, findings: []const rules.Finding, dead: []const rules.DeadRule, is_failed: bool) !void {2    var out = pretty_json.Writer.init(writer, .minified);3    try out.beginObject();4    try out.objectField("rules_checked");5    try out.write(rules_checked);6    try out.objectField("violations");7    try out.beginArray();8    for (findings) |finding| try json.writeFinding(allocator, &out, finding);9    try out.endArray();10    try out.objectField("dead_rules");11    try out.beginArray();12    for (dead) |dead_rule| {13        try out.beginObject();14        try out.objectField("rule");15        try out.write(dead_rule.rule);16        try out.objectField("reason");17        try out.write(dead_rule.reason);18        try out.endObject();19    }20    try out.endArray();21    try out.objectField("status");22    try out.write(if (!is_failed) "pass" else "fail");23    try out.endObject();24    try writer.writeByte('\n');25}

1pub fn writeNoRulesJson(writer: *std.Io.Writer) !void {2    var out = pretty_json.Writer.init(writer, .minified);3    try out.beginObject();4    try out.objectField("rules");5    try out.beginArray();6    try out.endArray();7    try out.objectField("violations");8    try out.beginArray();9    try out.endArray();10    try out.objectField("status");11    try out.write("no_rules");12    try out.endObject();13    try writer.writeByte('\n');14}

1pub fn writeText(allocator: std.mem.Allocator, writer: *std.Io.Writer, rule_list: []const rules.Rule, findings: []const rules.Finding, full: bool) !void {2    for (rule_list) |rule| {3        const finding = findingFor(findings, rule.name);4        if (finding == null) {5            try writer.print("PASS  {s}\n", .{rule.name});6            continue;7        }8        try writer.print("FAIL  {s}: {s}\n", .{ rule.name, finding.?.message });9        const witnesses = try findingWitnesses(allocator, finding.?);10        const limit = if (full) witnesses.len else @min(witnesses.len, @as(usize, 10));11        for (witnesses[0..limit]) |line| try writer.print("        {s}\n", .{line});12        if (!full and witnesses.len > limit) try writer.print("        ... and {d} more (use --full)\n", .{witnesses.len - limit});13    }14}

1pub fn run(2    allocator: std.mem.Allocator,3    root: []const u8,4    graph: graph_mod.Graph,5    concept_list: []const concepts.Concept,6    args: []const []const u8,7    limits: smg.Limits,8) !u8 {9    const list = try rules.load(allocator, root, limits.storage);10    const pos = try options.positional(allocator, args);11    if (list.len == 0) {12        if (options.hasJson(args)) {13            var out: std.Io.Writer.Allocating = .init(allocator);14            try render.writeNoRulesJson(&out.writer);15            _ = try output.writeOut(out.written());16            return 1;17        }18        const rules_path = try storage.files.rulesPath(allocator, root);19        try output.writeErrFmt(allocator, "Error: no rules defined; the check enforces nothing. Seed {s} or add one with smg rule add.\n", .{rules_path});20        return 1;21    }22    const checked_rules = try selection.selected(allocator, list, if (pos.len == 0) null else pos[0]);23    if (checked_rules.len == 0 and pos.len != 0) {24        try output.writeErrFmt(allocator, "Error: rule '{s}' not found.\n", .{pos[0]});25        return 1;26    }27    if (try rules.quantifiedMetricValidationMessage(allocator, graph, checked_rules)) |message| {28        try output.writeWrappedError(allocator, message);29        return 2;30    }31    var found: std.ArrayList(rules.Finding) = .empty;32    var prepared: rules.Check = undefined;33    prepared.prepare(graph, limits.analysis);34    for (checked_rules) |rule| {35        const maybe_finding = prepared.rule(allocator, rule, concept_list) catch |err| {36            if (try rules.checkErrorMessage(allocator, rule, err)) |message| {37                try output.writeWrappedError(allocator, message);38                return 2;39            }40            return err;41        };42        if (maybe_finding) |finding| try found.append(allocator, finding);43    }44    const findings = try found.toOwnedSlice(allocator);45    const dead = try rules.deadRules(allocator, graph, checked_rules);46    const is_failed = render.failed(findings, dead);47    if (options.hasJson(args)) {48        var out: std.Io.Writer.Allocating = .init(allocator);49        try render.writeJson(allocator, &out.writer, checked_rules.len, findings, dead, is_failed);50        _ = try output.writeOut(out.written());51    } else {52        var out: std.Io.Writer.Allocating = .init(allocator);53        try render.writeText(allocator, &out.writer, checked_rules, findings, options.hasFlag(args, "--full"));54        _ = try output.writeOut(out.written());55    }56    if (!options.hasJson(args)) {57        for (dead) |dead_rule| {58            try output.writeErrFmt(allocator, "warning: rule '{s}' cannot fire: {s}\n", .{ dead_rule.rule, dead_rule.reason });59        }60    }61    return if (!is_failed) 0 else 1;62}

1pub fn selected(allocator: std.mem.Allocator, rule_list: []const rules.Rule, maybe_name: ?[]const u8) ![]const rules.Rule {2    if (maybe_name == null) return rule_list;3    var out: std.ArrayList(rules.Rule) = .empty;4    for (rule_list) |rule| if (std.mem.eql(u8, rule.name, maybe_name.?)) try out.append(allocator, rule);5    return try out.toOwnedSlice(allocator);6}

1pub const command = @import("command.zig");2pub const refresh = @import("refresh.zig");3const render = @import("render.zig");4const runner = @import("run.zig");5const selection = @import("selection.zig");67pub const failed = render.failed;8pub const run = runner.run;9pub const selected = selection.selected;10pub const writeJson = render.writeJson;11pub const writeNoRulesJson = render.writeNoRulesJson;12pub const writeText = render.writeText;

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