pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/ast/ios/analyzers/iOSSwiftUIAdvancedRules.js

@@ -0,0 +1,333 @@
+/**
+ * iOS SwiftUI Advanced Rules
+ *
+ * Reglas avanzadas de SwiftUI:
+ * - PreferenceKey usage
+ * - Custom ViewModifiers
+ * - EnvironmentKey custom
+ * - Transaction y Animation avanzadas
+ * - Custom Layout protocol
+ * - ViewBuilder avanzados
+ */
+
+const { pushFinding } = require('../../ast-core');
+const fs = require('fs');
+
+class iOSSwiftUIAdvancedRules {
+  constructor(findings) {
+    this.findings = findings;
+  }
+
+  analyzeFile(filePath, ast) {
+    const content = this.readFile(filePath);
+    if (!content || !content.includes('import SwiftUI')) return;
+
+    this.checkPreferenceKeyUsage(filePath, content);
+    this.checkCustomViewModifiers(filePath, content);
+    this.checkEnvironmentKeyUsage(filePath, content);
+    this.checkTransactionUsage(filePath, content);
+    this.checkCustomLayoutProtocol(filePath, content);
+    this.checkViewBuilderAdvanced(filePath, content);
+    this.checkPreferenceKeyPerformance(filePath, content);
+    this.checkGeometryPreferences(filePath, content);
+    this.checkAnchorPreferences(filePath, content);
+    this.checkTaskModifierUsage(filePath, content);
+  }
+
+  /**
+   * 1. PreferenceKey usage - comunicación child → parent
+   */
+  checkPreferenceKeyUsage(filePath, content) {
+    const hasPreferenceKey = content.includes(': PreferenceKey');
+    const usesPreference = content.includes('.preference(') || content.includes('.onPreferenceChange');
+
+    if (usesPreference && !hasPreferenceKey) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.swiftui.preference_without_key',
+        severity: 'medium',
+        message: 'Uso de preference sin definir PreferenceKey custom. Puede causar type-safety issues.',
+        filePath,
+        line: this.findLineNumber(content, '.preference('),
+        suggestion: `Definir PreferenceKey propio:
+
+struct MyPreferenceKey: PreferenceKey {
+    static var defaultValue: CGFloat = 0
+    static func reduce(value: inout CGFloat, nextValue: () -> CGFloat) {
+        value = nextValue()
+    }
+}`
+      });
+    }
+  }
+
+  /**
+   * 2. Custom ViewModifiers - debe usar ViewModifier protocol
+   */
+  checkCustomViewModifiers(filePath, content) {
+    const extensionView = content.match(/extension\s+View\s*{([\s\S]*?)(?=\nextension|\n})/);
+
+    if (extensionView) {
+      const extensionBody = extensionView[1];
+      const funcs = (extensionBody.match(/func\s+\w+/g) || []).length;
+
+      if (funcs > 5) {
+        pushFinding(this.findings, {
+          ruleId: 'ios.swiftui.extension_view_bloated',
+          severity: 'medium',
+          message: `Extension View con ${funcs} funciones. Considerar usar custom ViewModifiers.`,
+          filePath,
+          line: this.findLineNumber(content, 'extension View'),
+          suggestion: `Extraer a ViewModifier protocol:
+
+extension View {
+    func myStyle() -> some View { ... }
+    func anotherStyle() -> some View { ... }
+}
+
+struct MyStyleModifier: ViewModifier {
+    func body(content: Content) -> some View {
+        content.padding()...
+    }
+}
+
+extension View {
+    func myStyle() -> some View {
+        modifier(MyStyleModifier())
+    }
+}`
+        });
+      }
+    }
+
+    const viewModifierMatches = content.match(/struct\s+(\w+):\s*ViewModifier/g);
+    if (viewModifierMatches) {
+      viewModifierMatches.forEach(match => {
+        const modifierName = match.match(/struct\s+(\w+)/)?.[1];
+        const hasBody = content.includes(`func body(content: Content)`);
+
+        if (!hasBody) {
+          pushFinding(this.findings, {
+            ruleId: 'ios.swiftui.viewmodifier_missing_body',
+            severity: 'high',
+            message: `ViewModifier '${modifierName}' debe implementar func body(content: Content) -> some View`,
+            filePath,
+            line: this.findLineNumber(content, match)
+          });
+        }
+      });
+    }
+  }
+
+  /**
+   * 3. EnvironmentKey custom para dependency injection
+   */
+  checkEnvironmentKeyUsage(filePath, content) {
+    const usesEnvironment = content.includes('@Environment(');
+    const hasCustomKey = content.includes(': EnvironmentKey');
+
+    const environmentMatches = content.match(/@Environment\(\\\.(\w+)\)/g);
+    if (environmentMatches && !hasCustomKey) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.swiftui.environment_missing_key',
+        severity: 'medium',
+        message: 'Uso de @Environment custom sin definir EnvironmentKey. Definir key para type-safety.',
+        filePath,
+        line: this.findLineNumber(content, '@Environment('),
+        suggestion: `Definir EnvironmentKey:
+
+private struct MyServiceKey: EnvironmentKey {
+    static let defaultValue: MyService = MyService()
+}
+
+extension EnvironmentValues {
+    var myService: MyService {
+        get { self[MyServiceKey.self] }
+        set { self[MyServiceKey.self] = newValue }
+    }
+}`
+      });
+    }
+  }
+
+  /**
+   * 4. Transaction usage para animaciones condicionales
+   */
+  checkTransactionUsage(filePath, content) {
+    const hasAnimation = content.includes('withAnimation') || content.includes('.animation(');
+    const hasConditional = content.includes('if ') && hasAnimation;
+    const hasTransaction = content.includes('transaction');
+
+    if (hasConditional && !hasTransaction) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.swiftui.conditional_animation_without_transaction',
+        severity: 'low',
+        message: 'Animaciones condicionales sin Transaction. Considerar usar transaction para mejor control.',
+        filePath,
+        line: 1,
+        suggestion: `var transaction = Transaction(animation: .default)
+transaction.disablesAnimations = condition
+withTransaction(transaction) { ... }`
+      });
+    }
+  }
+
+  /**
+   * 5. Custom Layout protocol (iOS 16+)
+   */
+  checkCustomLayoutProtocol(filePath, content) {
+    const geometryReaderCount = (content.match(/GeometryReader/g) || []).length;
+    const hasLayoutProtocol = content.includes(': Layout');
+
+    if (geometryReaderCount > 3 && !hasLayoutProtocol) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.swiftui.geometry_reader_instead_layout',
+        severity: 'medium',
+        message: `Múltiples GeometryReader para layouts. En iOS 16+ considerar usar Layout protocol.`,
+        filePath,
+        line: 1,
+        suggestion: `Layout protocol es más performante:
+
+struct MyCustomLayout: Layout {
+    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
+        // Custom logic
+    }
+
+    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
+    }
+}`
+      });
+    }
+  }
+
+  /**
+   * 6. @ViewBuilder avanzado - resultBuilder features
+   */
+  checkViewBuilderAdvanced(filePath, content) {
+    const viewBuilderMatches = content.match(/@ViewBuilder/g);
+
+    if (viewBuilderMatches && viewBuilderMatches.length > 0) {
+      const hasBuildEither = content.includes('buildEither');
+      const hasConditionals = content.includes('if ') || content.includes('switch ');
+
+      if (hasConditionals && !hasBuildEither && viewBuilderMatches.length > 3) {
+        pushFinding(this.findings, {
+          ruleId: 'ios.swiftui.viewbuilder_complex_conditionals',
+          severity: 'low',
+          message: '@ViewBuilder con condicionales complejos. Considerar simplificar o usar computed properties.',
+          filePath,
+          line: this.findLineNumber(content, '@ViewBuilder'),
+          suggestion: 'Extraer lógica condicional compleja fuera de @ViewBuilder'
+        });
+      }
+    }
+  }
+
+  /**
+   * 7. PreferenceKey performance - reduce() optimization
+   */
+  checkPreferenceKeyPerformance(filePath, content) {
+    const preferenceKeys = content.match(/struct\s+(\w+):\s*PreferenceKey[\s\S]*?static\s+func\s+reduce\(([\s\S]*?)\)/g);
+
+    if (preferenceKeys) {
+      preferenceKeys.forEach(key => {
+        const reduceBody = key.match(/reduce\(([\s\S]*?)\)/)?.[1];
+
+        if (reduceBody && (reduceBody.includes('.map') || reduceBody.includes('.filter'))) {
+          pushFinding(this.findings, {
+            ruleId: 'ios.swiftui.preferencekey_expensive_reduce',
+            severity: 'high',
+            message: 'PreferenceKey reduce() con operaciones O(n). Se llama frecuentemente, optimizar.',
+            filePath,
+            line: this.findLineNumber(content, 'static func reduce'),
+            suggestion: 'reduce() debe ser O(1). Evitar map/filter/reduce dentro.'
+          });
+        }
+      });
+    }
+  }
+
+  /**
+   * 8. GeometryPreferences optimization
+   */
+  checkGeometryPreferences(filePath, content) {
+    if (content.includes('GeometryReader') && content.includes('.preference(')) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.swiftui.geometry_with_preference',
+        severity: 'low',
+        message: 'GeometryReader con preference puede optimizarse con anchorPreference en algunos casos.',
+        filePath,
+        line: this.findLineNumber(content, 'GeometryReader'),
+        suggestion: 'anchorPreference evita GeometryReader para simple size/position'
+      });
+    }
+  }
+
+  /**
+   * 9. AnchorPreference usage
+   */
+  checkAnchorPreferences(filePath, content) {
+    const hasAnchor = content.includes('.anchorPreference');
+    const hasGeometryForPosition =
+      content.includes('GeometryReader') &&
+      (content.includes('.frame') || content.includes('.position'));
+
+    if (hasGeometryForPosition && !hasAnchor) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.swiftui.anchor_preference_opportunity',
+        severity: 'low',
+        message: 'GeometryReader para position/frame. Considerar anchorPreference para mejor performance.',
+        filePath,
+        line: 1,
+        suggestion: '.anchorPreference() es más eficiente que GeometryReader para coordenadas'
+      });
+    }
+  }
+
+  /**
+   * 10. Task modifier (iOS 15+) vs onAppear para async
+   */
+  checkTaskModifierUsage(filePath, content) {
+    const hasOnAppearAsync = content.match(/\.onAppear\s*{[\s\S]*?(async|await)[\s\S]*?}/);
+    const hasTaskModifier = content.includes('.task');
+
+    if (hasOnAppearAsync && !hasTaskModifier) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.swiftui.onappear_async_instead_task',
+        severity: 'medium',
+        message: 'onAppear con async/await. En iOS 15+ usar .task modifier para automatic cancellation.',
+        filePath,
+        line: this.findLineNumber(content, '.onAppear'),
+        suggestion: `Usar .task en lugar de .onAppear para async:
+
+.onAppear {
+    Task {
+        await loadData()
+    }
+}
+
+// ✅ .task cancela automáticamente cuando View desaparece
+.task {
+    await loadData()
+}`
+      });
+    }
+  }
+
+  findLineNumber(content, pattern) {
+    const lines = content.split('\n');
+    const index = lines.findIndex(line =>
+      typeof pattern === 'string' ? line.includes(pattern) : pattern.test(line)
+    );
+    return index !== -1 ? index + 1 : 1;
+  }
+
+  readFile(filePath) {
+    try {
+      return fs.readFileSync(filePath, 'utf-8');
+    } catch (error) {
+      return '';
+    }
+  }
+}
+
+module.exports = { iOSSwiftUIAdvancedRules };

package/scripts/hooks-system/infrastructure/ast/ios/analyzers/iOSTestingAdvancedRules.js

@@ -0,0 +1,225 @@
+/**
+ * iOS Testing Advanced Rules
+ * - Snapshot testing
+ * - Performance testing
+ * - Memory leak detection avanzado
+ * - UI testing patterns avanzados
+ */
+
+const { pushFinding } = require('../../ast-core');
+const fs = require('fs');
+const glob = require('glob');
+const path = require('path');
+
+class iOSTestingAdvancedRules {
+  constructor(findings, projectRoot) {
+    this.findings = findings;
+    this.projectRoot = projectRoot;
+  }
+
+  analyze() {
+    const testFiles = this.findTestFiles();
+
+    testFiles.forEach(file => {
+      const content = fs.readFileSync(file, 'utf-8');
+
+      this.checkSnapshotTesting(file, content);
+      this.checkPerformanceTesting(file, content);
+      this.checkMemoryLeakDetection(file, content);
+      this.checkUITestingPatterns(file, content);
+      this.checkAsyncTestingPatterns(file, content);
+      this.checkMockingPatterns(file, content);
+      this.checkTestCoverage(file, content);
+      this.checkTestNaming(file, content);
+    });
+  }
+
+  checkSnapshotTesting(file, content) {
+    const hasSnapshots = content.includes('SnapshotTesting') || content.includes('assertSnapshot');
+
+    if (!hasSnapshots && file.includes('UITests')) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.testing.missing_snapshot_tests',
+        severity: 'low',
+        message: 'UI tests sin snapshot testing. Considerar añadir para detectar regresiones visuales.',
+        filePath: file,
+        line: 1,
+        suggestion: `import SnapshotTesting
+
+func testViewSnapshot() {
+    assertSnapshot(matching: sut, as: .image)
+}`
+      });
+    }
+  }
+
+  checkPerformanceTesting(file, content) {
+    const hasPerformanceTests = content.includes('measure {') || content.includes('XCTMetric');
+    const hasManyTests = (content.match(/func\s+test/g) || []).length;
+
+    if (hasManyTests > 10 && !hasPerformanceTests) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.testing.missing_performance_tests',
+        severity: 'low',
+        message: 'Test suite sin performance tests. Añadir para detectar regresiones de performance.',
+        filePath: file,
+        line: 1,
+        suggestion: `func testPerformance() {
+    measure {
+        sut.heavyOperation()
+    }
+}`
+      });
+    }
+  }
+
+  checkMemoryLeakDetection(file, content) {
+    const hasWeakCapture = content.includes('[weak self]') || content.includes('[weak ');
+    const hasClosures = (content.match(/{[\s\S]*?}/g) || []).filter(c => c.length > 50).length;
+
+    if (hasClosures > 3 && !hasWeakCapture && !file.includes('MemoryLeakTests')) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.testing.missing_memory_leak_tests',
+        severity: 'medium',
+        message: 'Tests con closures pero sin verificación de memory leaks.',
+        filePath: file,
+        line: 1,
+        suggestion: `Añadir helper trackForMemoryLeaks:
+
+func testExample() {
+    let sut = makeSUT()
+    trackForMemoryLeaks(sut)
+    // test...
+}`
+      });
+    }
+  }
+
+  checkUITestingPatterns(file, content) {
+    if (!file.includes('UITests')) return;
+
+    const hasPageObject = content.includes('class ') && content.includes('Page');
+    const hasMultipleTests = (content.match(/func\s+test/g) || []).length > 5;
+
+    if (hasMultipleTests && !hasPageObject) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.testing.missing_page_object_pattern',
+        severity: 'medium',
+        message: 'UI tests sin Page Object pattern. Encapsular lógica de UI.',
+        filePath: file,
+        line: 1,
+        suggestion: `class LoginPage {
+    let app: XCUIApplication
+
+    var emailField: XCUIElement {
+        app.textFields["email"]
+    }
+
+    func login(email: String, password: String) {
+        emailField.tap()
+        emailField.typeText(email)
+        ...
+    }
+}`
+      });
+    }
+  }
+
+  checkAsyncTestingPatterns(file, content) {
+    const hasAsyncTests = content.includes('async ') && content.includes('func test');
+    const hasExpectation = content.includes('XCTestExpectation') || content.includes('expectation(');
+
+    if (hasAsyncTests && hasExpectation) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.testing.mixing_async_expectation',
+        severity: 'low',
+        message: 'Mezclando async/await con XCTestExpectation. Preferir async/await puro.',
+        filePath: file,
+        line: 1,
+        suggestion: `// ✅ Usar async/await directamente
+func testAsync() async {
+    let result = await sut.fetch()
+    XCTAssertNotNil(result)
+}`
+      });
+    }
+  }
+
+  checkMockingPatterns(file, content) {
+    const hasMocks = content.includes('Mock') || content.includes('Stub') || content.includes('Spy');
+    const hasProtocols = content.includes('protocol ');
+
+    if (!hasMocks && !hasProtocols && file.includes('Tests.swift')) {
+      const hasNetworking = content.includes('URLSession') || content.includes('API');
+
+      if (hasNetworking) {
+        pushFinding(this.findings, {
+          ruleId: 'ios.testing.missing_mocks',
+          severity: 'medium',
+          message: 'Tests con networking sin mocks/protocols. Añadir protocol para testability.',
+          filePath: file,
+          line: 1,
+          suggestion: `protocol NetworkServiceProtocol {
+    func fetch() async throws -> Data
+}
+
+class NetworkServiceMock: NetworkServiceProtocol {
+    var fetchResult: Result<Data, Error>?
+    func fetch() async throws -> Data { ... }
+}`
+        });
+      }
+    }
+  }
+
+  checkTestCoverage(file, content) {
+    const testCount = (content.match(/func\s+test\w+/g) || []).length;
+
+    if (testCount < 3 && file.includes('Tests.swift')) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.testing.low_test_count',
+        severity: 'low',
+        message: `Solo ${testCount} tests en archivo. Aumentar cobertura.`,
+        filePath: file,
+        line: 1
+      });
+    }
+  }
+
+  checkTestNaming(file, content) {
+    const testMatches = content.matchAll(/func\s+(test\w+)\(/g);
+
+    for (const match of testMatches) {
+      const testName = match[1];
+
+      if (testName.length < 15) {
+        pushFinding(this.findings, {
+          ruleId: 'ios.testing.test_name_not_descriptive',
+          severity: 'low',
+          message: `Test name '${testName}' poco descriptivo. Usar Given_When_Then.`,
+          filePath: file,
+          line: this.findLineNumber(content, testName),
+          suggestion: 'Ejemplo: test_fetchUsers_whenNetworkFails_shouldReturnError'
+        });
+      }
+    }
+  }
+
+  findTestFiles() {
+    return glob.sync('**/*Tests.swift', {
+      cwd: this.projectRoot,
+      ignore: ['**/Pods/**', '**/Build/**', '**/.build/**'],
+      absolute: true
+    });
+  }
+
+  findLineNumber(content, pattern) {
+    const lines = content.split('\n');
+    const index = lines.findIndex(line =>
+      typeof pattern === 'string' ? line.includes(pattern) : pattern.test(line)
+    );
+    return index !== -1 ? index + 1 : 1;
+  }
+}
+
+module.exports = { iOSTestingAdvancedRules };