public updateResultsInPlace()

in packages/cli/src/baseline/baseline-engine.ts [27:92]
52 lines of code
14 McCabe index (conditional complexity)

    public updateResultsInPlace(axeResults: AxeCoreResults, baselineOptions: BaselineOptions): BaselineEvaluation {
        const oldBaselineResults: BaselineResult[] = baselineOptions.baselineContent?.results ?? [];
        const newBaseline = this.baselineGenerator.generateBaseline(axeResults.violations, baselineOptions.urlNormalizer);
        const newBaselineResults: BaselineResult[] = newBaseline.results;

        const evaluation: BaselineEvaluation = {
            suggestedBaselineUpdate: baselineOptions.baselineContent ? null : newBaseline,
            fixedViolationsByRule: {},
            newViolationsByRule: {},
            totalFixedViolations: 0,
            totalNewViolations: 0,
        };

        if (baselineOptions.baselineContent) {
            evaluation.totalBaselineViolations = 0;
        }

        // Take advantage of the fact that baseline results are always sorted
        let oldResultIndex = 0;
        let newResultIndex = 0;

        while (oldResultIndex < oldBaselineResults.length || newResultIndex < newBaselineResults.length) {
            const oldBaselineResult = oldResultIndex < oldBaselineResults.length ? oldBaselineResults[oldResultIndex] : null;
            const newBaselineResult = newResultIndex < newBaselineResults.length ? newBaselineResults[newResultIndex] : null;

            const resultDetailComparison = this.compareResultDetails(oldBaselineResult, newBaselineResult);

            if (resultDetailComparison < 0) {
                // exists in oldBaselineResults but not newBaselineResults
                this.addFixedViolationsToEvaluation(oldBaselineResult, evaluation);
                oldResultIndex++;
            } else if (resultDetailComparison > 0) {
                // exists in newBaselineResults but not oldBaselineResults
                this.addNewViolationsToEvaluation(newBaselineResult, evaluation);
                this.updateAxeResults(axeResults, newBaselineResult);
                newResultIndex++;
            } else {
                // exists in both oldBaselineResults and newBaselineResults, so compare urls
                const urlComparison: UrlComparison = this.getUrlComparison(oldBaselineResult.urls, newBaselineResult.urls);
                if (urlComparison.fixedCount) {
                    this.updateCountsByRule(evaluation.fixedViolationsByRule, oldBaselineResult.rule, urlComparison.fixedCount);
                    evaluation.totalFixedViolations += urlComparison.fixedCount;
                }
                if (urlComparison.newUrls.size) {
                    this.updateCountsByRule(evaluation.newViolationsByRule, oldBaselineResult.rule, urlComparison.newUrls.size);
                    evaluation.totalNewViolations += urlComparison.newUrls.size;
                }
                evaluation.totalBaselineViolations += oldBaselineResult.urls.length;

                this.updateAxeResults(axeResults, newBaselineResult, urlComparison.newUrls);

                oldResultIndex++;
                newResultIndex++;
            }
        }

        if (
            evaluation.totalFixedViolations ||
            evaluation.totalNewViolations ||
            baselineOptions.baselineContent?.metadata?.fileFormatVersion !== newBaseline.metadata.fileFormatVersion
        ) {
            evaluation.suggestedBaselineUpdate = newBaseline;
        }

        return evaluation;
    }