@codeperfect/eslint-plugin 2.1.0 → 2.2.0

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.js

@@ -1,4 +1,5 @@
-import { hasAssertion, hasAsyncLogic, hasAwait, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, isValidAssertStatement, } from "../aaa/index.js";
+import { hasAssertion, isValidAssertStatement, } from "../aaa/analyzer.assertions.helpers.js";
+import { hasAsyncLogic, hasAwait, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, } from "../aaa/analyzer.classification.helpers.js";
 import { getAssertReferencedIdentifiers, isActResultAsserted, } from "./phase-purity-identifiers.js";
 /**
  * Collects the phase-purity state for one analyzed statement.
@@ -38,17 +39,39 @@ function getStatementPurityState(assertReferencedIdentifiers, statement) {
     };
 }
 /**
- * Checks whether the analyzed test block declares all AAA section comments.
+ * Checks whether the analyzed test block declares the Act and Assert sections.
  * @param analysis Parsed test-block analysis.
- * @returns True when Arrange, Act, and Assert are all present.
+ * @returns True when Act and Assert are both present.
  * @example
  * ```typescript
- * const complete = hasAllAaaSections({ sectionComments: [] } as never);
+ * const complete = hasRequiredAaaSections({ sectionComments: [] } as never);
  * void complete;
  * ```
  */
-function hasAllAaaSections(analysis) {
-    return ["Arrange", "Act", "Assert"].every((phase) => analysis.sectionComments.some((sectionComment) => sectionComment.phases.includes(phase)));
+function hasRequiredAaaSections(analysis) {
+    return ["Act", "Assert"].every((phase) => analysis.sectionComments.some((sectionComment) => sectionComment.phases.includes(phase)));
+}
+/**
+ * Reports violations for statements that belong to both Act and Assert.
+ * @param context ESLint rule context.
+ * @param statement Statement entry to report against.
+ * @param purityState Phase-purity state for the statement.
+ * @example
+ * ```typescript
+ * reportActAndAssertStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);
+ * ```
+ */
+function reportActAndAssertStatement(context, statement, purityState) {
+    if (purityState.containsMutation) {
+        context.report({ messageId: "mutationAfterAct", node: statement.node });
+        return;
+    }
+    if (purityState.isSetupLike && !purityState.isMeaningfulActContent) {
+        context.report({ messageId: "setupAfterAct", node: statement.node });
+    }
+    if (purityState.containsAssertion && !purityState.isValidAssert) {
+        context.report({ messageId: "nonAssertionInAssert", node: statement.node });
+    }
 }
 /**
  * Reports Act-only phase violations for one statement.
@@ -67,15 +90,28 @@ function reportActOnlyStatement(context, statement, purityState) {
             node: statement.node,
         });
     }
-    if (purityState.allowsAssert &&
-        purityState.containsAssertion &&
-        !purityState.isValidAssert) {
-        context.report({ messageId: "nonAssertionInAssert", node: statement.node });
-    }
     if (purityState.isSetupLike && !purityState.isMeaningfulActContent) {
         context.report({ messageId: "setupAfterAct", node: statement.node });
     }
 }
+/**
+ * Reports violations for statements that belong to both Arrange and Act.
+ * @param context ESLint rule context.
+ * @param statement Statement entry to report against.
+ * @param purityState Phase-purity state for the statement.
+ * @example
+ * ```typescript
+ * reportArrangeAndActStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);
+ * ```
+ */
+function reportArrangeAndActStatement(context, statement, purityState) {
+    if (purityState.containsAssertion) {
+        context.report({
+            messageId: "assertionOutsideAssert",
+            node: statement.node,
+        });
+    }
+}
 /**
  * Reports Arrange-only phase violations for one statement.
  * @param context ESLint rule context.
@@ -135,7 +171,7 @@ function reportAssertOnlyStatement(context, statement, purityState) {
  * ```
  */
 function reportPhasePurityViolations(context, analysis) {
-    if (!hasAllAaaSections(analysis)) {
+    if (!hasRequiredAaaSections(analysis)) {
         return;
     }
     let hasMeaningfulAct = false;
@@ -164,17 +200,43 @@ function reportPhasePurityViolations(context, analysis) {
  * ```
  */
 function reportStatementViolations(context, statement, purityState) {
-    if (purityState.allowsArrange && !purityState.allowsAct) {
+    if (purityState.allowsArrange &&
+        !purityState.allowsAct &&
+        !purityState.allowsAssert) {
         reportArrangeOnlyStatement(context, statement, purityState);
         return;
     }
-    if (purityState.allowsAct && !purityState.allowsArrange) {
+    if (purityState.allowsAct &&
+        !purityState.allowsArrange &&
+        !purityState.allowsAssert) {
         reportActOnlyStatement(context, statement, purityState);
         return;
     }
-    if (purityState.allowsAssert && !purityState.allowsAct) {
+    if (purityState.allowsAssert &&
+        !purityState.allowsAct &&
+        !purityState.allowsArrange) {
         reportAssertOnlyStatement(context, statement, purityState);
+        return;
+    }
+    if (purityState.allowsArrange &&
+        purityState.allowsAct &&
+        !purityState.allowsAssert) {
+        reportArrangeAndActStatement(context, statement, purityState);
+        return;
+    }
+    if (purityState.allowsAct &&
+        purityState.allowsAssert &&
+        !purityState.allowsArrange) {
+        reportActAndAssertStatement(context, statement, purityState);
+        return;
+    }
+    if (purityState.allowsArrange &&
+        purityState.allowsAct &&
+        purityState.allowsAssert &&
+        purityState.containsAssertion &&
+        !purityState.isValidAssert) {
+        context.report({ messageId: "nonAssertionInAssert", node: statement.node });
     }
 }
 export { reportPhasePurityViolations };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"phase-purity-reporting.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\r\n\r\nimport type { TestBlockAnalysis } from \"../aaa\";\r\n\r\nimport {\r\n  hasAssertion,\r\n  hasAsyncLogic,\r\n  hasAwait,\r\n  hasCapturableActResult,\r\n  hasMutation,\r\n  isMeaningfulActStatement,\r\n  isSetupLikeStatement,\r\n  isValidAssertStatement,\r\n} from \"../aaa\";\r\nimport {\r\n  getAssertReferencedIdentifiers,\r\n  isActResultAsserted,\r\n} from \"./phase-purity-identifiers\";\r\n\r\n/** Type definition for rule data. */\r\ninterface StatementPurityState {\r\n  /** Whether the statement belongs to Act. */\r\n  allowsAct: boolean;\r\n\r\n  /** Whether the statement belongs to Arrange. */\r\n  allowsArrange: boolean;\r\n\r\n  /** Whether the statement belongs to Assert. */\r\n  allowsAssert: boolean;\r\n\r\n  /** Whether the statement contains an assertion. */\r\n  containsAssertion: boolean;\r\n\r\n  /** Whether the statement contains async logic. */\r\n  containsAsyncLogic: boolean;\r\n\r\n  /** Whether the statement contains an await expression. */\r\n  containsAwait: boolean;\r\n\r\n  /** Whether the statement mutates state. */\r\n  containsMutation: boolean;\r\n\r\n  /** Whether the statement performs meaningful Act work. */\r\n  isMeaningfulAct: boolean;\r\n\r\n  /** Whether the statement counts as meaningful Act content overall. */\r\n  isMeaningfulActContent: boolean;\r\n\r\n  /** Whether the statement looks like setup. */\r\n  isSetupLike: boolean;\r\n\r\n  /** Whether the statement is a valid assert-phase statement. */\r\n  isValidAssert: boolean;\r\n}\r\n\r\n/**\r\n * Collects the phase-purity state for one analyzed statement.\r\n * @param assertReferencedIdentifiers Referenced identifiers collected from Assert.\r\n * @param statement Statement entry to classify.\r\n * @returns Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * const state = getStatementPurityState(new Set<string>(), { node: { type: \"ExpressionStatement\" } as never, phases: [] });\r\n * void state;\r\n * ```\r\n */\r\nfunction getStatementPurityState(\r\n  assertReferencedIdentifiers: Set<string>,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n): StatementPurityState {\r\n  const allowsArrange = statement.phases.includes(\"Arrange\");\r\n  const allowsAct = statement.phases.includes(\"Act\");\r\n  const allowsAssert = statement.phases.includes(\"Assert\");\r\n  const containsAssertion = hasAssertion(statement.node);\r\n  const containsAsyncLogic = hasAsyncLogic(statement.node);\r\n  const containsAwait = hasAwait(statement.node);\r\n  const containsMutation = hasMutation(statement.node);\r\n  const isMeaningfulAct = isMeaningfulActStatement(statement.node);\r\n  const isMeaningfulActContent =\r\n    isMeaningfulAct ||\r\n    hasCapturableActResult(statement.node) ||\r\n    isActResultAsserted(assertReferencedIdentifiers, statement.node);\r\n\r\n  return {\r\n    allowsAct,\r\n    allowsArrange,\r\n    allowsAssert,\r\n    containsAssertion,\r\n    containsAsyncLogic,\r\n    containsAwait,\r\n    containsMutation,\r\n    isMeaningfulAct,\r\n    isMeaningfulActContent,\r\n    isSetupLike: isSetupLikeStatement(statement.node),\r\n    isValidAssert: isValidAssertStatement(statement.node),\r\n  };\r\n}\r\n\r\n/**\r\n * Checks whether the analyzed test block declares all AAA section comments.\r\n * @param analysis Parsed test-block analysis.\r\n * @returns True when Arrange, Act, and Assert are all present.\r\n * @example\r\n * ```typescript\r\n * const complete = hasAllAaaSections({ sectionComments: [] } as never);\r\n * void complete;\r\n * ```\r\n */\r\nfunction hasAllAaaSections(analysis: TestBlockAnalysis): boolean {\r\n  return [\"Arrange\", \"Act\", \"Assert\"].every((phase) =>\r\n    analysis.sectionComments.some((sectionComment) =>\r\n      sectionComment.phases.includes(phase as never),\r\n    ),\r\n  );\r\n}\r\n\r\n/**\r\n * Reports Act-only phase violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportActOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportActOnlyStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsAssertion && !purityState.allowsAssert) {\r\n    context.report({\r\n      messageId: \"assertionOutsideAssert\",\r\n      node: statement.node,\r\n    });\r\n  }\r\n\r\n  if (\r\n    purityState.allowsAssert &&\r\n    purityState.containsAssertion &&\r\n    !purityState.isValidAssert\r\n  ) {\r\n    context.report({ messageId: \"nonAssertionInAssert\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.isSetupLike && !purityState.isMeaningfulActContent) {\r\n    context.report({ messageId: \"setupAfterAct\", node: statement.node });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports Arrange-only phase violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportArrangeOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportArrangeOnlyStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsAssertion && !purityState.allowsAssert) {\r\n    context.report({\r\n      messageId: \"assertionOutsideAssert\",\r\n      node: statement.node,\r\n    });\r\n  }\r\n\r\n  if (purityState.containsAwait) {\r\n    context.report({ messageId: \"awaitOutsideAct\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.containsAsyncLogic) {\r\n    context.report({ messageId: \"asyncInArrange\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.isMeaningfulAct) {\r\n    context.report({ messageId: \"actionInArrange\", node: statement.node });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports Assert-only phase violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportAssertOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportAssertOnlyStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsAwait) {\r\n    context.report({ messageId: \"awaitOutsideAct\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.containsMutation) {\r\n    context.report({ messageId: \"mutationAfterAct\", node: statement.node });\r\n    return;\r\n  }\r\n\r\n  if (!purityState.isValidAssert) {\r\n    context.report({ messageId: \"nonAssertionInAssert\", node: statement.node });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports all enforce-aaa-phase-purity violations for one test block.\r\n * @param context ESLint rule context.\r\n * @param analysis Parsed test-block analysis.\r\n * @example\r\n * ```typescript\r\n * reportPhasePurityViolations({ report() {} } as never, { sectionComments: [], statements: [] } as never);\r\n * ```\r\n */\r\nfunction reportPhasePurityViolations(\r\n  context: Rule.RuleContext,\r\n  analysis: TestBlockAnalysis,\r\n): void {\r\n  if (!hasAllAaaSections(analysis)) {\r\n    return;\r\n  }\r\n\r\n  let hasMeaningfulAct = false;\r\n  const assertReferencedIdentifiers = getAssertReferencedIdentifiers(analysis);\r\n\r\n  for (const statement of analysis.statements) {\r\n    const purityState = getStatementPurityState(\r\n      assertReferencedIdentifiers,\r\n      statement,\r\n    );\r\n\r\n    hasMeaningfulAct ||=\r\n      purityState.allowsAct && purityState.isMeaningfulActContent;\r\n    reportStatementViolations(context, statement, purityState);\r\n  }\r\n\r\n  if (!hasMeaningfulAct) {\r\n    context.report({\r\n      messageId: \"missingMeaningfulAct\",\r\n      node: analysis.callExpression,\r\n    });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports any phase-purity violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportStatementViolations({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportStatementViolations(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.allowsArrange && !purityState.allowsAct) {\r\n    reportArrangeOnlyStatement(context, statement, purityState);\r\n    return;\r\n  }\r\n\r\n  if (purityState.allowsAct && !purityState.allowsArrange) {\r\n    reportActOnlyStatement(context, statement, purityState);\r\n    return;\r\n  }\r\n\r\n  if (purityState.allowsAssert && !purityState.allowsAct) {\r\n    reportAssertOnlyStatement(context, statement, purityState);\r\n  }\r\n}\r\n\r\nexport { reportPhasePurityViolations };\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"phase-purity-reporting.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\r\n\r\nimport type { TestBlockAnalysis } from \"../aaa/types\";\r\n\r\nimport {\r\n  hasAssertion,\r\n  isValidAssertStatement,\r\n} from \"../aaa/analyzer.assertions.helpers\";\r\nimport {\r\n  hasAsyncLogic,\r\n  hasAwait,\r\n  hasCapturableActResult,\r\n  hasMutation,\r\n  isMeaningfulActStatement,\r\n  isSetupLikeStatement,\r\n} from \"../aaa/analyzer.classification.helpers\";\r\nimport {\r\n  getAssertReferencedIdentifiers,\r\n  isActResultAsserted,\r\n} from \"./phase-purity-identifiers\";\r\n\r\n/** Type definition for rule data. */\r\ninterface StatementPurityState {\r\n  /** Whether the statement belongs to Act. */\r\n  allowsAct: boolean;\r\n\r\n  /** Whether the statement belongs to Arrange. */\r\n  allowsArrange: boolean;\r\n\r\n  /** Whether the statement belongs to Assert. */\r\n  allowsAssert: boolean;\r\n\r\n  /** Whether the statement contains an assertion. */\r\n  containsAssertion: boolean;\r\n\r\n  /** Whether the statement contains async logic. */\r\n  containsAsyncLogic: boolean;\r\n\r\n  /** Whether the statement contains an await expression. */\r\n  containsAwait: boolean;\r\n\r\n  /** Whether the statement mutates state. */\r\n  containsMutation: boolean;\r\n\r\n  /** Whether the statement performs meaningful Act work. */\r\n  isMeaningfulAct: boolean;\r\n\r\n  /** Whether the statement counts as meaningful Act content overall. */\r\n  isMeaningfulActContent: boolean;\r\n\r\n  /** Whether the statement looks like setup. */\r\n  isSetupLike: boolean;\r\n\r\n  /** Whether the statement is a valid assert-phase statement. */\r\n  isValidAssert: boolean;\r\n}\r\n\r\n/**\r\n * Collects the phase-purity state for one analyzed statement.\r\n * @param assertReferencedIdentifiers Referenced identifiers collected from Assert.\r\n * @param statement Statement entry to classify.\r\n * @returns Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * const state = getStatementPurityState(new Set<string>(), { node: { type: \"ExpressionStatement\" } as never, phases: [] });\r\n * void state;\r\n * ```\r\n */\r\nfunction getStatementPurityState(\r\n  assertReferencedIdentifiers: Set<string>,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n): StatementPurityState {\r\n  const allowsArrange = statement.phases.includes(\"Arrange\");\r\n  const allowsAct = statement.phases.includes(\"Act\");\r\n  const allowsAssert = statement.phases.includes(\"Assert\");\r\n  const containsAssertion = hasAssertion(statement.node);\r\n  const containsAsyncLogic = hasAsyncLogic(statement.node);\r\n  const containsAwait = hasAwait(statement.node);\r\n  const containsMutation = hasMutation(statement.node);\r\n  const isMeaningfulAct = isMeaningfulActStatement(statement.node);\r\n  const isMeaningfulActContent =\r\n    isMeaningfulAct ||\r\n    hasCapturableActResult(statement.node) ||\r\n    isActResultAsserted(assertReferencedIdentifiers, statement.node);\r\n\r\n  return {\r\n    allowsAct,\r\n    allowsArrange,\r\n    allowsAssert,\r\n    containsAssertion,\r\n    containsAsyncLogic,\r\n    containsAwait,\r\n    containsMutation,\r\n    isMeaningfulAct,\r\n    isMeaningfulActContent,\r\n    isSetupLike: isSetupLikeStatement(statement.node),\r\n    isValidAssert: isValidAssertStatement(statement.node),\r\n  };\r\n}\r\n\r\n/**\r\n * Checks whether the analyzed test block declares the Act and Assert sections.\r\n * @param analysis Parsed test-block analysis.\r\n * @returns True when Act and Assert are both present.\r\n * @example\r\n * ```typescript\r\n * const complete = hasRequiredAaaSections({ sectionComments: [] } as never);\r\n * void complete;\r\n * ```\r\n */\r\nfunction hasRequiredAaaSections(analysis: TestBlockAnalysis): boolean {\r\n  return [\"Act\", \"Assert\"].every((phase) =>\r\n    analysis.sectionComments.some((sectionComment) =>\r\n      sectionComment.phases.includes(phase as never),\r\n    ),\r\n  );\r\n}\r\n\r\n/**\r\n * Reports violations for statements that belong to both Act and Assert.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportActAndAssertStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportActAndAssertStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsMutation) {\r\n    context.report({ messageId: \"mutationAfterAct\", node: statement.node });\r\n    return;\r\n  }\r\n\r\n  if (purityState.isSetupLike && !purityState.isMeaningfulActContent) {\r\n    context.report({ messageId: \"setupAfterAct\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.containsAssertion && !purityState.isValidAssert) {\r\n    context.report({ messageId: \"nonAssertionInAssert\", node: statement.node });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports Act-only phase violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportActOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportActOnlyStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsAssertion && !purityState.allowsAssert) {\r\n    context.report({\r\n      messageId: \"assertionOutsideAssert\",\r\n      node: statement.node,\r\n    });\r\n  }\r\n\r\n  if (purityState.isSetupLike && !purityState.isMeaningfulActContent) {\r\n    context.report({ messageId: \"setupAfterAct\", node: statement.node });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports violations for statements that belong to both Arrange and Act.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportArrangeAndActStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportArrangeAndActStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsAssertion) {\r\n    context.report({\r\n      messageId: \"assertionOutsideAssert\",\r\n      node: statement.node,\r\n    });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports Arrange-only phase violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportArrangeOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportArrangeOnlyStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsAssertion && !purityState.allowsAssert) {\r\n    context.report({\r\n      messageId: \"assertionOutsideAssert\",\r\n      node: statement.node,\r\n    });\r\n  }\r\n\r\n  if (purityState.containsAwait) {\r\n    context.report({ messageId: \"awaitOutsideAct\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.containsAsyncLogic) {\r\n    context.report({ messageId: \"asyncInArrange\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.isMeaningfulAct) {\r\n    context.report({ messageId: \"actionInArrange\", node: statement.node });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports Assert-only phase violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportAssertOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportAssertOnlyStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsAwait) {\r\n    context.report({ messageId: \"awaitOutsideAct\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.containsMutation) {\r\n    context.report({ messageId: \"mutationAfterAct\", node: statement.node });\r\n    return;\r\n  }\r\n\r\n  if (!purityState.isValidAssert) {\r\n    context.report({ messageId: \"nonAssertionInAssert\", node: statement.node });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports all enforce-aaa-phase-purity violations for one test block.\r\n * @param context ESLint rule context.\r\n * @param analysis Parsed test-block analysis.\r\n * @example\r\n * ```typescript\r\n * reportPhasePurityViolations({ report() {} } as never, { sectionComments: [], statements: [] } as never);\r\n * ```\r\n */\r\nfunction reportPhasePurityViolations(\r\n  context: Rule.RuleContext,\r\n  analysis: TestBlockAnalysis,\r\n): void {\r\n  if (!hasRequiredAaaSections(analysis)) {\r\n    return;\r\n  }\r\n\r\n  let hasMeaningfulAct = false;\r\n  const assertReferencedIdentifiers = getAssertReferencedIdentifiers(analysis);\r\n\r\n  for (const statement of analysis.statements) {\r\n    const purityState = getStatementPurityState(\r\n      assertReferencedIdentifiers,\r\n      statement,\r\n    );\r\n\r\n    hasMeaningfulAct ||=\r\n      purityState.allowsAct && purityState.isMeaningfulActContent;\r\n    reportStatementViolations(context, statement, purityState);\r\n  }\r\n\r\n  if (!hasMeaningfulAct) {\r\n    context.report({\r\n      messageId: \"missingMeaningfulAct\",\r\n      node: analysis.callExpression,\r\n    });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports any phase-purity violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportStatementViolations({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportStatementViolations(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (\r\n    purityState.allowsArrange &&\r\n    !purityState.allowsAct &&\r\n    !purityState.allowsAssert\r\n  ) {\r\n    reportArrangeOnlyStatement(context, statement, purityState);\r\n    return;\r\n  }\r\n\r\n  if (\r\n    purityState.allowsAct &&\r\n    !purityState.allowsArrange &&\r\n    !purityState.allowsAssert\r\n  ) {\r\n    reportActOnlyStatement(context, statement, purityState);\r\n    return;\r\n  }\r\n\r\n  if (\r\n    purityState.allowsAssert &&\r\n    !purityState.allowsAct &&\r\n    !purityState.allowsArrange\r\n  ) {\r\n    reportAssertOnlyStatement(context, statement, purityState);\r\n    return;\r\n  }\r\n\r\n  if (\r\n    purityState.allowsArrange &&\r\n    purityState.allowsAct &&\r\n    !purityState.allowsAssert\r\n  ) {\r\n    reportArrangeAndActStatement(context, statement, purityState);\r\n    return;\r\n  }\r\n\r\n  if (\r\n    purityState.allowsAct &&\r\n    purityState.allowsAssert &&\r\n    !purityState.allowsArrange\r\n  ) {\r\n    reportActAndAssertStatement(context, statement, purityState);\r\n    return;\r\n  }\r\n\r\n  if (\r\n    purityState.allowsArrange &&\r\n    purityState.allowsAct &&\r\n    purityState.allowsAssert &&\r\n    purityState.containsAssertion &&\r\n    !purityState.isValidAssert\r\n  ) {\r\n    context.report({ messageId: \"nonAssertionInAssert\", node: statement.node });\r\n  }\r\n}\r\n\r\nexport { reportPhasePurityViolations };\r\n"]}

package/dist/domain/testing/{require-aaa-sections → enforce-aaa-structure}/missing-section-fixes.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from "eslint";
-import type { AaaPhase, TestBlockAnalysis } from "../aaa/index.js";
+import type { AaaPhase, TestBlockAnalysis } from "../aaa/types.js";
 /**
  * Builds autofix edits for each missing AAA section marker.
  * @param analysis Parsed test-block analysis.

package/dist/domain/testing/enforce-aaa-structure/missing-section-fixes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"missing-section-fixes.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-structure/missing-section-fixes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAsGhE;;;;;;;;;;;GAWG;AACH,iBAAS,wBAAwB,CAC/B,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,EAAE,SAAS,QAAQ,EAAE,EACpC,KAAK,EAAE,IAAI,CAAC,SAAS,GACpB,IAAI,CAAC,GAAG,EAAE,CAWZ;AA4GD,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/domain/testing/enforce-aaa-structure/missing-section-fixes.js

@@ -0,0 +1,150 @@
+import { aaaPhaseOrder, getLineStartRange, } from "../aaa/analyzer.analysis.helpers.js";
+/**
+ * Groups missing phases by insertion offset.
+ * @param anchors Anchor statements available for insertion.
+ * @param missingSections Missing AAA phases to insert.
+ * @returns Map of source offsets to phases that should be inserted there.
+ * @example
+ * ```typescript
+ * const anchorMap = buildAnchorMap({ firstStatement: { range: [0, 1] } as never, lastStatement: { range: [2, 3] } as never, middleStatement: { range: [1, 2] } as never }, ["Arrange"]);
+ * void anchorMap;
+ * ```
+ */
+function buildAnchorMap(anchors, missingSections) {
+    const anchorMap = new Map();
+    for (const phase of missingSections) {
+        const anchorNode = getAnchorNode(anchors, phase);
+        const existing = anchorMap.get(anchorNode.range[0]) ?? [];
+        existing.push(phase);
+        anchorMap.set(anchorNode.range[0], existing);
+    }
+    return anchorMap;
+}
+/**
+ * Builds one autofix that inserts missing section markers before a statement.
+ * @param input Composite input for one missing-section fix.
+ * @returns Fix that inserts the missing section marker text.
+ * @example
+ * ```typescript
+ * const fix = buildMissingSectionFix({ analysis: { newline: "\n", sourceText: "value" } as never, fixer: {} as never, offset: 0, phases: ["Arrange"] });
+ * void fix;
+ * ```
+ */
+function buildMissingSectionFix(input) {
+    const { analysis, fixer, offset, phases } = input;
+    const sourceLines = analysis.sourceText.split(/\r\n|\n/u);
+    const sortedPhases = phases.toSorted((left, right) => aaaPhaseOrder[left] - aaaPhaseOrder[right]);
+    const statementLine = analysis.sourceText
+        .slice(0, offset)
+        .split(/\r\n|\n/u).length;
+    const lineStartRange = getLineStartRange(analysis.sourceText, statementLine);
+    const [previousLine = ""] = statementLine > 1
+        ? sourceLines.slice(statementLine - 2, statementLine - 1)
+        : [];
+    const needsLeadingBlankLine = shouldInsertLeadingBlankLine(sortedPhases, previousLine);
+    const [currentLine = ""] = sourceLines.slice(statementLine - 1, statementLine);
+    const indentation = getLineIndentation(currentLine);
+    return fixer.insertTextBeforeRange(lineStartRange, `${needsLeadingBlankLine ? analysis.newline : ""}${indentation}// ${sortedPhases.join(" & ")}${analysis.newline}`);
+}
+/**
+ * Builds autofix edits for each missing AAA section marker.
+ * @param analysis Parsed test-block analysis.
+ * @param missingSections Missing AAA phases to insert.
+ * @param fixer ESLint fixer instance.
+ * @returns Fixes that add the missing section comments.
+ * @example
+ * ```typescript
+ * const fixes = buildMissingSectionFixes({ newline: "\n", sourceText: "value" } as never, ["Arrange"], {} as never);
+ * void fixes;
+ * ```
+ */
+function buildMissingSectionFixes(analysis, missingSections, fixer) {
+    const anchors = getSectionAnchors(analysis);
+    if (anchors === void 0) {
+        return [];
+    }
+    return [...buildAnchorMap(anchors, missingSections).entries()].map(([offset, phases]) => buildMissingSectionFix({ analysis, fixer, offset, phases }));
+}
+/**
+ * Selects the anchor statement used for one missing AAA phase.
+ * @param anchors Anchor statements available for insertion.
+ * @param phase Missing phase being inserted.
+ * @returns Statement node used as the insertion anchor.
+ * @example
+ * ```typescript
+ * const anchor = getAnchorNode({ firstStatement: {} as never, lastStatement: {} as never, middleStatement: {} as never }, "Arrange");
+ * void anchor;
+ * ```
+ */
+function getAnchorNode(anchors, phase) {
+    switch (phase) {
+        case "Act": {
+            return anchors.middleStatement;
+        }
+        case "Arrange": {
+            return anchors.firstStatement;
+        }
+        case "Assert": {
+            return anchors.lastStatement;
+        }
+        default: {
+            return anchors.lastStatement;
+        }
+    }
+}
+/**
+ * Reads the indentation prefix from a source line.
+ * @param lineText Source line text.
+ * @returns Leading whitespace for the line.
+ * @example
+ * ```typescript
+ * const indentation = getLineIndentation("  value");
+ * void indentation;
+ * ```
+ */
+function getLineIndentation(lineText) {
+    const trimmedLine = lineText.trimStart();
+    return lineText.slice(0, lineText.length - trimmedLine.length);
+}
+/**
+ * Selects the statement nodes used as insertion anchors for missing sections.
+ * @param analysis Parsed test-block analysis.
+ * @returns Anchor statements for Arrange, Act, and Assert insertion.
+ * @example
+ * ```typescript
+ * const anchors = getSectionAnchors({ statements: [] } as never);
+ * void anchors;
+ * ```
+ */
+function getSectionAnchors(analysis) {
+    const [firstStatementEntry] = analysis.statements;
+    const middleStatementEntry = analysis.statements[Math.min(analysis.statements.length - 1, Math.floor(analysis.statements.length / 2))];
+    const lastStatementEntry = analysis.statements.at(-1);
+    if (firstStatementEntry === void 0 ||
+        middleStatementEntry === void 0 ||
+        lastStatementEntry === void 0) {
+        return void 0;
+    }
+    return {
+        firstStatement: firstStatementEntry.node,
+        lastStatement: lastStatementEntry.node,
+        middleStatement: middleStatementEntry.node,
+    };
+}
+/**
+ * Determines whether a missing section insertion needs a blank line prefix.
+ * @param phases Missing phases inserted at the same offset.
+ * @param previousLine Source line immediately above the insertion point.
+ * @returns Whether the inserted marker should start with a blank line.
+ * @example
+ * ```typescript
+ * const actual = shouldInsertLeadingBlankLine(["Act"], "run();");
+ * void actual;
+ * ```
+ */
+function shouldInsertLeadingBlankLine(phases, previousLine) {
+    return (phases.some((phase) => phase !== "Arrange") &&
+        previousLine.trim().length > 0);
+}
+export { buildMissingSectionFixes };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"missing-section-fixes.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-structure/missing-section-fixes.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { AaaPhase, TestBlockAnalysis } from \"../aaa/types\";\n\nimport {\n  aaaPhaseOrder,\n  getLineStartRange,\n} from \"../aaa/analyzer.analysis.helpers\";\n\n/** Composite input for building one missing-section fix. */\ninterface MissingSectionFixInput {\n  /** Parsed test-block analysis. */\n  analysis: TestBlockAnalysis;\n\n  /** ESLint fixer instance. */\n  fixer: Rule.RuleFixer;\n\n  /** Source offset where the section marker should be inserted. */\n  offset: number;\n\n  /** Missing phases that share the same insertion offset. */\n  phases: readonly AaaPhase[];\n}\n\n/** Anchor statements used to place missing AAA section comments. */\ninterface StatementAnchors {\n  /** First statement available for an Arrange insertion. */\n  firstStatement: TestBlockAnalysis[\"statements\"][number][\"node\"];\n\n  /** Last statement available for an Assert insertion. */\n  lastStatement: TestBlockAnalysis[\"statements\"][number][\"node\"];\n\n  /** Middle statement available for an Act insertion. */\n  middleStatement: TestBlockAnalysis[\"statements\"][number][\"node\"];\n}\n\n/**\n * Groups missing phases by insertion offset.\n * @param anchors Anchor statements available for insertion.\n * @param missingSections Missing AAA phases to insert.\n * @returns Map of source offsets to phases that should be inserted there.\n * @example\n * ```typescript\n * const anchorMap = buildAnchorMap({ firstStatement: { range: [0, 1] } as never, lastStatement: { range: [2, 3] } as never, middleStatement: { range: [1, 2] } as never }, [\"Arrange\"]);\n * void anchorMap;\n * ```\n */\nfunction buildAnchorMap(\n  anchors: StatementAnchors,\n  missingSections: readonly AaaPhase[],\n): Map<number, AaaPhase[]> {\n  const anchorMap = new Map<number, AaaPhase[]>();\n\n  for (const phase of missingSections) {\n    const anchorNode = getAnchorNode(anchors, phase);\n    const existing = anchorMap.get(anchorNode.range[0]) ?? [];\n\n    existing.push(phase);\n    anchorMap.set(anchorNode.range[0], existing);\n  }\n\n  return anchorMap;\n}\n\n/**\n * Builds one autofix that inserts missing section markers before a statement.\n * @param input Composite input for one missing-section fix.\n * @returns Fix that inserts the missing section marker text.\n * @example\n * ```typescript\n * const fix = buildMissingSectionFix({ analysis: { newline: \"\\n\", sourceText: \"value\" } as never, fixer: {} as never, offset: 0, phases: [\"Arrange\"] });\n * void fix;\n * ```\n */\nfunction buildMissingSectionFix(input: MissingSectionFixInput): Rule.Fix {\n  const { analysis, fixer, offset, phases } = input;\n  const sourceLines = analysis.sourceText.split(/\\r\\n|\\n/u);\n  const sortedPhases = phases.toSorted(\n    (left, right) => aaaPhaseOrder[left] - aaaPhaseOrder[right],\n  );\n  const statementLine = analysis.sourceText\n    .slice(0, offset)\n    .split(/\\r\\n|\\n/u).length;\n  const lineStartRange = getLineStartRange(analysis.sourceText, statementLine);\n  const [previousLine = \"\"] =\n    statementLine > 1\n      ? sourceLines.slice(statementLine - 2, statementLine - 1)\n      : [];\n  const needsLeadingBlankLine = shouldInsertLeadingBlankLine(\n    sortedPhases,\n    previousLine,\n  );\n  const [currentLine = \"\"] = sourceLines.slice(\n    statementLine - 1,\n    statementLine,\n  );\n  const indentation = getLineIndentation(currentLine);\n\n  return fixer.insertTextBeforeRange(\n    lineStartRange,\n    `${needsLeadingBlankLine ? analysis.newline : \"\"}${indentation}// ${sortedPhases.join(\" & \")}${analysis.newline}`,\n  );\n}\n\n/**\n * Builds autofix edits for each missing AAA section marker.\n * @param analysis Parsed test-block analysis.\n * @param missingSections Missing AAA phases to insert.\n * @param fixer ESLint fixer instance.\n * @returns Fixes that add the missing section comments.\n * @example\n * ```typescript\n * const fixes = buildMissingSectionFixes({ newline: \"\\n\", sourceText: \"value\" } as never, [\"Arrange\"], {} as never);\n * void fixes;\n * ```\n */\nfunction buildMissingSectionFixes(\n  analysis: TestBlockAnalysis,\n  missingSections: readonly AaaPhase[],\n  fixer: Rule.RuleFixer,\n): Rule.Fix[] {\n  const anchors = getSectionAnchors(analysis);\n\n  if (anchors === void 0) {\n    return [];\n  }\n\n  return [...buildAnchorMap(anchors, missingSections).entries()].map(\n    ([offset, phases]) =>\n      buildMissingSectionFix({ analysis, fixer, offset, phases }),\n  );\n}\n\n/**\n * Selects the anchor statement used for one missing AAA phase.\n * @param anchors Anchor statements available for insertion.\n * @param phase Missing phase being inserted.\n * @returns Statement node used as the insertion anchor.\n * @example\n * ```typescript\n * const anchor = getAnchorNode({ firstStatement: {} as never, lastStatement: {} as never, middleStatement: {} as never }, \"Arrange\");\n * void anchor;\n * ```\n */\nfunction getAnchorNode(\n  anchors: StatementAnchors,\n  phase: AaaPhase,\n): StatementAnchors[keyof StatementAnchors] {\n  switch (phase) {\n    case \"Act\": {\n      return anchors.middleStatement;\n    }\n    case \"Arrange\": {\n      return anchors.firstStatement;\n    }\n    case \"Assert\": {\n      return anchors.lastStatement;\n    }\n    default: {\n      return anchors.lastStatement;\n    }\n  }\n}\n\n/**\n * Reads the indentation prefix from a source line.\n * @param lineText Source line text.\n * @returns Leading whitespace for the line.\n * @example\n * ```typescript\n * const indentation = getLineIndentation(\"  value\");\n * void indentation;\n * ```\n */\nfunction getLineIndentation(lineText: string): string {\n  const trimmedLine = lineText.trimStart();\n\n  return lineText.slice(0, lineText.length - trimmedLine.length);\n}\n\n/**\n * Selects the statement nodes used as insertion anchors for missing sections.\n * @param analysis Parsed test-block analysis.\n * @returns Anchor statements for Arrange, Act, and Assert insertion.\n * @example\n * ```typescript\n * const anchors = getSectionAnchors({ statements: [] } as never);\n * void anchors;\n * ```\n */\nfunction getSectionAnchors(\n  analysis: TestBlockAnalysis,\n): StatementAnchors | undefined {\n  const [firstStatementEntry] = analysis.statements;\n  const middleStatementEntry =\n    analysis.statements[\n      Math.min(\n        analysis.statements.length - 1,\n        Math.floor(analysis.statements.length / 2),\n      )\n    ];\n  const lastStatementEntry = analysis.statements.at(-1);\n\n  if (\n    firstStatementEntry === void 0 ||\n    middleStatementEntry === void 0 ||\n    lastStatementEntry === void 0\n  ) {\n    return void 0;\n  }\n\n  return {\n    firstStatement: firstStatementEntry.node,\n    lastStatement: lastStatementEntry.node,\n    middleStatement: middleStatementEntry.node,\n  };\n}\n\n/**\n * Determines whether a missing section insertion needs a blank line prefix.\n * @param phases Missing phases inserted at the same offset.\n * @param previousLine Source line immediately above the insertion point.\n * @returns Whether the inserted marker should start with a blank line.\n * @example\n * ```typescript\n * const actual = shouldInsertLeadingBlankLine([\"Act\"], \"run();\");\n * void actual;\n * ```\n */\nfunction shouldInsertLeadingBlankLine(\n  phases: readonly AaaPhase[],\n  previousLine: string,\n): boolean {\n  return (\n    phases.some((phase) => phase !== \"Arrange\") &&\n    previousLine.trim().length > 0\n  );\n}\n\nexport { buildMissingSectionFixes };\n"]}

package/dist/domain/testing/enforce-aaa-structure/rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-structure/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAqFnC,kFAAkF;AAClF,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAwCnC,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-structure/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAuGnC,kFAAkF;AAClF,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAqEnC,CAAC;AA2MF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}