pumuki 6.3.148 → 6.3.149

package/core/facts/detectors/text/ios.test.ts

@@ -6,6 +6,7 @@ import {
   findSwiftOpenClosedSwitchMatch,
   findSwiftConcreteDependencyDipMatch,
   findSwiftPresentationSrpMatch,
+  findSwiftXCTestSrpMatch,
   hasSwiftAnyViewUsage,
   hasSwiftCallbackStyleSignature,
   hasSwiftCornerRadiusUsage,
@@ -888,6 +889,69 @@ final class PumukiOcpIosCanaryUseCase {
   assert.match(match.expected_fix, /estrategia|protocolo|registry/i);
 });
 
+test('findSwiftOpenClosedSwitchMatch detecta switch sobre outcome en Coordinator iOS', () => {
+  const source = `public final class LaunchFlowCoordinator {
+  public func bootstrap() async {
+    let outcome = await appConfigurationUseCase.execute()
+    switch outcome {
+    case .mandatoryUpdate:
+      route = .updateRequired
+    case .maintenance:
+      route = .maintenance
+    case .proceed:
+      route = .home
+    }
+  }
+}
+`;
+
+  const match = findSwiftOpenClosedSwitchMatch(source);
+
+  assert.ok(match);
+  assert.equal(match.primary_node.name, 'LaunchFlowCoordinator');
+  assert.deepEqual(match.related_nodes, [
+    { kind: 'member', name: 'discriminator switch: outcome', lines: [4] },
+    { kind: 'member', name: 'case .mandatoryUpdate', lines: [5] },
+    { kind: 'member', name: 'case .maintenance', lines: [7] },
+    { kind: 'member', name: 'case .proceed', lines: [9] },
+  ]);
+  assert.match(match.why, /OCP/);
+});
+
+test('findSwiftXCTestSrpMatch detecta XCTestCase con responsabilidades mezcladas', () => {
+  const source = `import XCTest
+
+final class LaunchFlowCoordinatorConfigTests: XCTestCase {
+  func test_bootstrap_whenMandatoryUpdate_routesToUpdateRequired() async {}
+  func test_bootstrap_whenSessionIsValid_routesHome() async {}
+  func test_completeOnboarding_marksProgressAndRoutesToLogin() async {}
+}
+`;
+
+  const match = findSwiftXCTestSrpMatch(source);
+
+  assert.ok(match);
+  assert.equal(match.primary_node.name, 'LaunchFlowCoordinatorConfigTests');
+  assert.deepEqual(match.related_nodes, [
+    { kind: 'member', name: 'session routing tests', lines: [5] },
+    { kind: 'member', name: 'onboarding progress tests', lines: [6] },
+  ]);
+  assert.match(match.why, /XCTestCase|SRP/);
+});
+
+test('findSwiftXCTestSrpMatch permite XCTestCase enfocado en una responsabilidad', () => {
+  const source = `import XCTest
+
+final class LaunchFlowCoordinatorNonBlockingConfigTests: XCTestCase {
+  func test_bootstrap_whenConfigFetchFailsWithCache_usesCachedConfigAndContinues() async {}
+  func test_bootstrap_whenOptionalUpdate_allowsAccessAndContinues() async {}
+  func test_bootstrap_whenProceed_continuesToSessionValidation() async {}
+}
+`;
+
+  assert.equal(findSwiftXCTestSrpMatch(source), undefined);
+});
+
 test('findSwiftInterfaceSegregationMatch devuelve payload semantico para ISP-iOS en application', () => {
   const source = `
 protocol PumukiIspIosCanarySessionManaging {

package/core/facts/detectors/text/ios.ts

@@ -32,6 +32,8 @@ export type SwiftPresentationSrpMatch = {
   lines: readonly number[];
 };
 
+export type SwiftXCTestSrpMatch = SwiftPresentationSrpMatch;
+
 export type SwiftConcreteDependencyDipMatch = {
   primary_node: SwiftSemanticNodeMatch;
   related_nodes: readonly SwiftSemanticNodeMatch[];
@@ -1185,6 +1187,100 @@ export const findSwiftPresentationSrpMatch = (
   };
 };
 
+export const findSwiftXCTestSrpMatch = (source: string): SwiftXCTestSrpMatch | undefined => {
+  if (!hasSwiftXCTestCaseSubclassUsage(source)) {
+    return undefined;
+  }
+
+  const classPattern = /\b(?:final\s+)?class\s+([A-Za-z0-9_]*Tests?)\s*:\s*XCTestCase\b/;
+  const classLines = collectSwiftRegexLines(source, classPattern);
+  if (classLines.length === 0) {
+    return undefined;
+  }
+
+  const classLine = source.split(/\r?\n/)[classLines[0] - 1] ?? '';
+  const className = classLine.match(classPattern)?.[1];
+  if (!className) {
+    return undefined;
+  }
+
+  const sourceLines = source.split(/\r?\n/);
+  const familyPatterns: ReadonlyArray<{
+    key: string;
+    name: string;
+    tokens: readonly string[];
+  }> = [
+    { key: 'configuration', name: 'configuration outcome tests', tokens: ['config', 'configuration', 'update', 'cache'] },
+    { key: 'session', name: 'session routing tests', tokens: ['session', 'login', 'auth', 'valid', 'invalid'] },
+    { key: 'onboarding', name: 'onboarding progress tests', tokens: ['onboarding', 'progress', 'completeonboarding'] },
+    { key: 'permissions', name: 'permissions routing tests', tokens: ['permission', 'camera', 'location', 'notification'] },
+    { key: 'tutorial', name: 'tutorial or feature discovery tests', tokens: ['tutorial', 'featurediscovery'] },
+    { key: 'splash', name: 'splash delay tests', tokens: ['splash', 'delay', 'start'] },
+  ];
+  const matchesFamily = (value: string, tokens: readonly string[]): boolean => {
+    const normalizedValue = value.toLowerCase();
+    return tokens.some((token) => normalizedValue.includes(token));
+  };
+
+  const classFamilyKeys = new Set(
+    familyPatterns
+      .filter((entry) => matchesFamily(className, entry.tokens))
+      .map((entry) => entry.key)
+  );
+  const matchedFamilies = new Map<string, SwiftSemanticNodeMatch>();
+
+  sourceLines.forEach((line, index) => {
+    const sanitizedLine = stripSwiftLineForSemanticScan(line);
+    const methodMatch = sanitizedLine.match(/\bfunc\s+(test[A-Za-z0-9_]+)\s*\(/);
+    const methodName = methodMatch?.[1];
+    if (!methodName) {
+      return;
+    }
+
+    for (const family of familyPatterns) {
+      if (!matchesFamily(methodName, family.tokens)) {
+        continue;
+      }
+      if (classFamilyKeys.has(family.key)) {
+        continue;
+      }
+      if (!matchedFamilies.has(family.key)) {
+        matchedFamilies.set(family.key, {
+          kind: 'member',
+          name: family.name,
+          lines: [index + 1],
+        });
+      }
+    }
+  });
+
+  const relatedNodes = [...matchedFamilies.values()];
+  if (relatedNodes.length < 2) {
+    return undefined;
+  }
+
+  const relatedNodeNames = relatedNodes.map((node) => node.name).join(', ');
+  const allLines = sortedUniqueLines([
+    ...classLines,
+    ...relatedNodes.flatMap((node) => [...node.lines]),
+  ]);
+
+  return {
+    primary_node: {
+      kind: 'class',
+      name: className,
+      lines: classLines,
+    },
+    related_nodes: relatedNodes,
+    why: `${className} mezcla ${relatedNodeNames} dentro del mismo XCTestCase, rompiendo SRP en la suite de tests.`,
+    impact:
+      'La suite acumula múltiples razones de cambio, oculta regresiones por responsabilidad y hace más difícil aislar el baseline afectado antes de PRE_WRITE.',
+    expected_fix:
+      'Divide la suite por responsabilidad observable: configuración, sesión, onboarding, permisos, tutorial o splash deben vivir en XCTestCase separados.',
+    lines: allLines,
+  };
+};
+
 export const findSwiftConcreteDependencyDipMatch = (
   source: string
 ): SwiftConcreteDependencyDipMatch | undefined => {
@@ -1275,7 +1371,7 @@ export const findSwiftOpenClosedSwitchMatch = (
   }
 
   const lines = source.split(/\r?\n/);
-  const discriminatorPattern = /\b(?:kind|type|mode|channel|variant|provider|route|flow|source|experience)\b/i;
+  const discriminatorPattern = /\b(?:kind|type|mode|channel|variant|provider|route|flow|source|experience|outcome|state|status|configuration|config)\b/i;
   const switchPattern = /\bswitch\s+([A-Za-z_][A-Za-z0-9_\.]*)\s*\{/;
 
   for (let index = 0; index < lines.length; index += 1) {

package/core/facts/extractHeuristicFacts.ts

@@ -901,11 +901,30 @@ export const extractHeuristicFacts = (
       }
     }
 
-    if (
-      params.detectedPlatforms.ios?.detected &&
-      isIOSSwiftPath(fileFact.path) &&
-      !isSwiftTestPath(fileFact.path)
-    ) {
+    if (params.detectedPlatforms.ios?.detected && isIOSSwiftPath(fileFact.path)) {
+      if (isSwiftTestPath(fileFact.path)) {
+        const semanticTestSrpMatch = TextIOS.findSwiftXCTestSrpMatch(fileFact.content);
+        if (semanticTestSrpMatch) {
+          heuristicFacts.push(
+            createHeuristicFact({
+              ruleId: 'heuristics.ios.solid.srp.presentation-mixed-responsibilities.ast',
+              code: 'HEURISTICS_IOS_SOLID_SRP_XCTEST_MIXED_RESPONSIBILITIES_AST',
+              message:
+                'Semantic iOS SRP heuristic detected an XCTestCase suite mixing multiple responsibilities.',
+              filePath: fileFact.path,
+              lines: semanticTestSrpMatch.lines,
+              severity: 'CRITICAL',
+              primary_node: semanticTestSrpMatch.primary_node,
+              related_nodes: semanticTestSrpMatch.related_nodes,
+              why: semanticTestSrpMatch.why,
+              impact: semanticTestSrpMatch.impact,
+              expected_fix: semanticTestSrpMatch.expected_fix,
+            })
+          );
+        }
+      }
+
+      if (!isSwiftTestPath(fileFact.path)) {
       if (isIOSApplicationOrPresentationPath(fileFact.path)) {
         const semanticOcpMatch = TextIOS.findSwiftOpenClosedSwitchMatch(fileFact.content);
         if (semanticOcpMatch) {
@@ -1027,6 +1046,7 @@ export const extractHeuristicFacts = (
           })
         );
       }
+      }
     }
 
     if (

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.148",
+  "version": "6.3.149",
   "description": "Enterprise-grade AST Intelligence System with multi-platform support (iOS, Android, Backend, Frontend) and Feature-First + DDD + Clean Architecture enforcement. Includes dynamic violations API for intelligent querying.",
   "main": "index.js",
   "bin": {