@diullei/codeguardian/dist/combinators/ForEachRule.js

Open-source developer tool to validate and enforce architectural rules, especially for AI-generated code

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ForEachRule = void 0;
const core_1 = require("../core");
class ForEachRule extends core_1.CombinatorRule {
    selector;
    assertion;
    constructor(id, selector, assertion) {
        super(id, [selector, assertion]);
        this.selector = selector;
        this.assertion = assertion;
    }
    countRules() {
        return 1;
    }
    async evaluate(context) {
        const selectorResult = await this.selector.evaluate(context);
        const items = selectorResult.details?.items || [];
        const violations = [];
        for (const item of items) {
            let itemToAssert = item;
            if (item && typeof item === 'object' && 'path' in item && !item.content) {
                const isDeleted = 'status' in item && item.status === 'deleted';
                if (!isDeleted) {
                    try {
                        const content = await context.repository.getFileContent(item.path);
                        itemToAssert = { ...item, content };
                    }
                    catch (error) {
                        itemToAssert = item;
                    }
                }
            }
            const itemContext = { ...context, currentItem: itemToAssert };
            try {
                if (this.assertion instanceof core_1.AssertionRule) {
                    const isPropertyAssertion = this.assertion.constructor.name === 'AssertPropertyRule';
                    const itemForAssertion = isPropertyAssertion
                        ? itemToAssert
                        : (itemToAssert.content || itemToAssert);
                    const assertionResult = await this.assertion.assertWithDetails(itemForAssertion, itemContext);
                    if (!assertionResult.passed) {
                        const violation = {
                            file: this.getItemFile(item),
                            line: this.getItemLine(item),
                            message: assertionResult.message ||
                                `Assertion '${this.assertion.id}' failed`,
                            severity: 'error',
                            context: assertionResult.context,
                        };
                        violations.push(violation);
                    }
                }
                else {
                    const result = await this.assertion.evaluate(itemContext);
                    if (!result.passed) {
                        const enhancedViolations = (result.violations || []).map(v => ({
                            ...v,
                            file: v.file || this.getItemFile(item),
                            line: v.line || this.getItemLine(item),
                        }));
                        violations.push(...enhancedViolations);
                    }
                }
            }
            catch (error) {
                violations.push({
                    file: this.getItemFile(item),
                    line: this.getItemLine(item),
                    message: `Error evaluating assertion: ${error instanceof Error ? error.message : String(error)}`,
                    severity: 'error',
                });
            }
        }
        return {
            passed: violations.length === 0,
            violations,
        };
    }
    getItemFile(item) {
        if (item && typeof item === 'object') {
            if ('file' in item)
                return String(item.file);
            if ('path' in item)
                return String(item.path);
        }
        return undefined;
    }
    getItemLine(item) {
        if (item && typeof item === 'object') {
            if ('line' in item && typeof item.line === 'number')
                return item.line;
            if ('lineNumber' in item && typeof item.lineNumber === 'number')
                return item.lineNumber;
        }
        return undefined;
    }
}
exports.ForEachRule = ForEachRule;
//# sourceMappingURL=ForEachRule.js.map