tiny.smg.command.rules.add

1const std = @import("std");23const smg = @import("../../root.zig");4const model = smg.model;5const options = smg.cli.options;6const output = smg.cli.output;7const rules_mod = smg.rules;8const text = smg.text;910const QuantifiedAdd = struct {11    selector: []const u8,12    assertion: []const u8,13};1415const AddKind = union(enum) {16    deny: []const u8,17    invariant: []const u8,18    quantified: QuantifiedAdd,19};2021pub fn parse(allocator: std.mem.Allocator, args: []const []const u8, name: []const u8) !rules_mod.Rule {22    return switch (try addKind(allocator, args)) {23        .deny => |pattern| try denyRule(allocator, args, name, pattern),24        .invariant => |invariant| try invariantRule(allocator, args, name, invariant),25        .quantified => |quantified| try quantifiedRule(allocator, args, name, quantified),26    };27}2829fn addKind(allocator: std.mem.Allocator, args: []const []const u8) !AddKind {30    const deny = options.flagValue(args, "--deny");31    const exclude_source = options.flagValue(args, "--exclude-source");32    const allow_empty_target = options.hasFlag(args, "--allow-empty-target");33    const invariant = options.flagValue(args, "--invariant");34    const forall = options.flagValue(args, "--forall");35    const assertion = options.flagValue(args, "--assert");36    var kind_count: usize = 0;37    if (deny != null) kind_count += 1;38    if (invariant != null) kind_count += 1;39    if (forall != null) kind_count += 1;40    if (kind_count > 1) {41        try output.writeErrFmt(allocator, "Error: specify exactly one of --deny, --invariant, or --forall.\n", .{});42        return error.RuleValidation;43    }44    if (kind_count == 0) {45        try output.writeErrFmt(allocator, "Error: specify one of --deny, --invariant, or --forall.\n", .{});46        return error.RuleValidation;47    }48    if (forall != null and assertion == null) {49        try output.writeErrFmt(allocator, "Error: --assert is required with --forall.\n", .{});50        return error.RuleValidation;51    }52    if (forall == null and assertion != null) {53        try output.writeErrFmt(allocator, "Error: --assert may only be used with --forall.\n", .{});54        return error.RuleValidation;55    }56    if (deny == null and exclude_source != null) {57        try output.writeErrFmt(58            allocator,59            "Error: --exclude-source may only be used with --deny.\n",60            .{},61        );62        return error.RuleValidation;63    }64    if (deny == null and allow_empty_target) {65        try output.writeErrFmt(66            allocator,67            "Error: --allow-empty-target may only be used with --deny.\n",68            .{},69        );70        return error.RuleValidation;71    }72    if (deny) |pattern| return .{ .deny = pattern };73    if (invariant) |value| return .{ .invariant = value };74    return .{ .quantified = .{ .selector = forall.?, .assertion = assertion.? } };75}7677fn denyRule(allocator: std.mem.Allocator, args: []const []const u8, name: []const u8, pattern: []const u8) !rules_mod.Rule {78    _ = rules_mod.parseDenyPattern(pattern) catch |err| {79        if (err == error.InvalidDenyPattern) {80            try output.writeErrFmt(allocator, "Error: invalid deny pattern: '{s}'\n", .{pattern});81            return error.RuleValidation;82        }83        return err;84    };85    return .{86        .name = try allocator.dupe(u8, name),87        .type = try allocator.dupe(u8, "deny"),88        .pattern = try allocator.dupe(u8, pattern),89        .exclude_source = if (options.flagValue(args, "--exclude-source")) |value|90            try allocator.dupe(u8, value)91        else92            null,93        .allow_empty_target = options.hasFlag(args, "--allow-empty-target"),94        .scope = try ruleScope(allocator, args),95    };96}9798fn invariantRule(allocator: std.mem.Allocator, args: []const []const u8, name: []const u8, invariant: []const u8) !rules_mod.Rule {99    if (options.flagValue(args, "--baseline")) |baseline| {100        if (!std.mem.eql(u8, invariant, "namespace-handle-imports")) {101            try output.writeErrFmt(102                allocator,103                "Error: --baseline may only be used with the namespace-handle-imports invariant.\n",104                .{},105            );106            return error.RuleValidation;107        }108        rules_mod.validateNamespaceHandleImportBaseline(baseline) catch {109            try output.writeErrFmt(allocator, "Error: --baseline must be COUNT:SHA256.\n", .{});110            return error.RuleValidation;111        };112    }113    return .{114        .name = try allocator.dupe(u8, name),115        .type = try allocator.dupe(u8, "invariant"),116        .invariant = try allocator.dupe(u8, invariant),117        .params = try ruleParams(allocator, args),118        .scope = try ruleScope(allocator, args),119    };120}121122fn quantifiedRule(allocator: std.mem.Allocator, args: []const []const u8, name: []const u8, quantified: QuantifiedAdd) !rules_mod.Rule {123    const unknown_metrics = rules_mod.unknownAssertionMetrics(allocator, quantified.assertion) catch |err| {124        if (try rules_mod.assertionErrorMessage(allocator, quantified.assertion, err)) |message| {125            try output.writeErrFmt(allocator, "Error: {s}\n", .{message});126            return error.RuleValidation;127        }128        return err;129    };130    if (unknown_metrics.len != 0) {131        try output.writeErrFmt(allocator, "Error: unknown metric identifier(s) in rule '{s}': {s}\n", .{ name, try text.list.joinStrings(allocator, unknown_metrics, ", ") });132        return error.RuleValidation;133    }134    return .{135        .name = try allocator.dupe(u8, name),136        .type = try allocator.dupe(u8, "quantified"),137        .selector = try allocator.dupe(u8, quantified.selector),138        .assertion = try allocator.dupe(u8, quantified.assertion),139        .scope = try ruleScope(allocator, args),140    };141}142143fn ruleScope(allocator: std.mem.Allocator, args: []const []const u8) !?[]const u8 {144    return if (options.flagValue(args, "--scope")) |value| try allocator.dupe(u8, value) else null;145}146147fn ruleParams(allocator: std.mem.Allocator, args: []const []const u8) ![]const model.Pair {148    var out: std.ArrayList(model.Pair) = .empty;149    if (options.flagValue(args, "--entry-points")) |entry| {150        try out.append(allocator, .{ .key = try allocator.dupe(u8, "entry_points"), .value = try allocator.dupe(u8, entry) });151    }152    if (options.flagValue(args, "--baseline")) |baseline| {153        try out.append(allocator, .{ .key = try allocator.dupe(u8, "baseline"), .value = try allocator.dupe(u8, baseline) });154    }155    return try out.toOwnedSlice(allocator);156}157158test "parse add builds invariant rule params" {159    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);160    defer arena.deinit();161    const allocator = arena.allocator();162    const args = &.{ "add", "live", "--invariant", "no-dead-code", "--entry-points", "main,cli.*", "--scope", "tools.smg.*" };163    const rule = try parse(allocator, args, "live");164    try std.testing.expectEqualStrings("live", rule.name);165    try std.testing.expectEqualStrings("invariant", rule.type);166    try std.testing.expectEqualStrings("no-dead-code", rule.invariant.?);167    try std.testing.expectEqualStrings("tools.smg.*", rule.scope.?);168    try std.testing.expectEqual(@as(usize, 1), rule.params.len);169    try std.testing.expectEqualStrings("entry_points", rule.params[0].key);170    try std.testing.expectEqualStrings("main,cli.*", rule.params[0].value);171}172173test "parse add builds namespace import baseline" {174    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);175    defer arena.deinit();176    const allocator = arena.allocator();177    const args = &.{178        "add",179        "root-handles",180        "--invariant",181        "namespace-handle-imports",182        "--baseline",183        "3:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",184    };185    const rule = try parse(allocator, args, "root-handles");186    try std.testing.expectEqual(@as(usize, 1), rule.params.len);187    try std.testing.expectEqualStrings("baseline", rule.params[0].key);188    try std.testing.expectEqualStrings(189        "3:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",190        rule.params[0].value,191    );192}193194test "parse add rejects namespace import baseline for other invariants" {195    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);196    defer arena.deinit();197    const allocator = arena.allocator();198    const args = &.{ "add", "acyclic", "--invariant", "no-cycles", "--baseline", "0:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" };199    try std.testing.expectError(error.RuleValidation, parse(allocator, args, "acyclic"));200}201202test "parse add rejects incomplete namespace import baseline" {203    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);204    defer arena.deinit();205    const allocator = arena.allocator();206    const args = &.{ "add", "root-handles", "--invariant", "namespace-handle-imports", "--baseline", "0:00" };207    try std.testing.expectError(error.RuleValidation, parse(allocator, args, "root-handles"));208}209210test "parse add builds deny dead-target policy" {211    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);212    defer arena.deinit();213    const allocator = arena.allocator();214    const args = &.{215        "add",216        "no-back-root",217        "--deny",218        "pkg.feature.* -[imports]-> pkg.feature.root",219        "--exclude-source",220        "*.test",221        "--allow-empty-target",222    };223    const rule = try parse(allocator, args, "no-back-root");224    try std.testing.expectEqualStrings("deny", rule.type);225    try std.testing.expectEqualStrings(226        "pkg.feature.* -[imports]-> pkg.feature.root",227        rule.pattern.?,228    );229    try std.testing.expectEqualStrings("*.test", rule.exclude_source.?);230    try std.testing.expect(rule.allow_empty_target);231}232233test "parse add rejects empty-target policy for non-deny rules" {234    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);235    defer arena.deinit();236    const allocator = arena.allocator();237    const args = &.{ "add", "acyclic", "--invariant", "no-cycles", "--allow-empty-target" };238    try std.testing.expectError(error.RuleValidation, parse(allocator, args, "acyclic"));239}

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