@saulwade/swl-ses 1.0.0

package/reglas/lenguajes/swift/estilo-codigo.md

@@ -0,0 +1,238 @@
+# Regla: Estilo de Código Swift
+
+Esta regla es OBLIGATORIA para todo código Swift nuevo o modificado.
+Swift moderno (6+) tiene un sistema de tipos y un modelo de concurrencia diseñados
+para eliminar clases enteras de bugs. Usarlos correctamente no es opcional.
+
+---
+
+## Linters obligatorios: SwiftFormat y SwiftLint
+
+- **SwiftFormat** aplica formato consistente automáticamente. Corre en CI como verificación bloqueante.
+- **SwiftLint** detecta anti-patrones, violaciones de estilo y código peligroso.
+- Configurar el build phase de Xcode para correr SwiftLint al compilar.
+
+```bash
+# Instalación vía Homebrew
+brew install swiftformat swiftlint
+
+# .swiftformat — configuración base
+--indent 4
+--linebreaks lf
+--maxwidth 120
+--wraparguments before-first
+--closingparen balanced
+```
+
+```yaml
+# .swiftlint.yml
+opt_in_rules:
+  - force_unwrapping
+  - implicitly_unwrapped_optional
+  - missing_docs
+disabled_rules:
+  - todo
+excluded:
+  - Pods
+  - .build
+line_length: 120
+function_body_length:
+  warning: 40
+  error: 50
+```
+
+---
+
+## let sobre var: inmutabilidad por defecto
+
+Declarar `let` siempre que el valor no cambie. `var` solo cuando la mutación es necesaria.
+
+```swift
+// MAL — var donde el valor nunca se reasigna
+var nombre = "Juan"
+var total = calcularTotal(items)
+
+// BIEN — let comunica inmutabilidad
+let nombre = "Juan"
+let total = calcularTotal(items)
+```
+
+---
+
+## struct con value semantics, class solo para referencias
+
+En Swift, `struct` es el tipo por defecto. Usar `class` solo cuando se necesita
+semántica de referencia (ciclo de vida compartido, herencia obligatoria).
+
+```swift
+// BIEN — struct para modelos de datos
+struct Pedido {
+    let id: UUID
+    let items: [ItemPedido]
+    let total: Decimal
+}
+
+// BIEN — class cuando se necesita referencia compartida
+final class GestorConexion {
+    private var conexion: URLSession
+    // El gestor se pasa por referencia a múltiples servicios
+}
+
+// MAL — class donde struct es suficiente
+class UsuarioDto {
+    var nombre: String
+    var email: String
+    init(nombre: String, email: String) { ... }
+}
+```
+
+---
+
+## Swift 6: actors para estado compartido entre tareas
+
+Los `actor`s garantizan acceso exclusivo a su estado. Reemplaza locks, DispatchQueues
+y toda sincronización manual para datos compartidos entre tareas concurrentes.
+
+```swift
+// MAL — clase con estado mutable compartido entre hilos (data race)
+class Cache {
+    private var datos: [String: Data] = [:]
+    func guardar(_ data: Data, clave: String) { datos[clave] = data }
+    func obtener(clave: String) -> Data? { datos[clave] }
+}
+
+// BIEN — actor: acceso sincronizado por el compilador
+actor Cache {
+    private var datos: [String: Data] = [:]
+    func guardar(_ data: Data, clave: String) { datos[clave] = data }
+    func obtener(clave: String) -> Data? { datos[clave] }
+}
+
+// Uso — el compilador fuerza await para accesos al actor
+let cache = Cache()
+await cache.guardar(data, clave: "perfil")
+let perfil = await cache.obtener(clave: "perfil")
+```
+
+---
+
+## Concurrencia estructurada: async/await sobre Combine
+
+En código nuevo, preferir `async/await` sobre Combine.
+Combine se mantiene para flujos reactivos UI complejos o cuando la base de código
+ya lo usa extensamente.
+
+```swift
+// MAL — Combine para una sola operación asíncrona (sobre-ingeniería)
+func obtenerUsuario(id: UUID) -> AnyPublisher<Usuario, Error> {
+    URLSession.shared.dataTaskPublisher(for: url)
+        .map(\.data)
+        .decode(type: Usuario.self, decoder: JSONDecoder())
+        .eraseToAnyPublisher()
+}
+
+// BIEN — async/await: lineal, legible, con propagación de errores tipada
+func obtenerUsuario(id: UUID) async throws -> Usuario {
+    let (data, _) = try await URLSession.shared.data(from: url)
+    return try JSONDecoder().decode(Usuario.self, from: data)
+}
+```
+
+---
+
+## guard let para early return (no if let anidados)
+
+```swift
+// MAL — pirámide de la muerte con if let anidados
+func procesarPedido(datos: [String: Any]?) {
+    if let datos = datos {
+        if let idString = datos["id"] as? String {
+            if let id = UUID(uuidString: idString) {
+                // lógica principal al nivel 3 de anidamiento
+            }
+        }
+    }
+}
+
+// BIEN — guard let: early return, lógica principal al nivel 0
+func procesarPedido(datos: [String: Any]?) {
+    guard let datos = datos else { return }
+    guard let idString = datos["id"] as? String else { return }
+    guard let id = UUID(uuidString: idString) else {
+        logger.warning("ID inválido en datos de pedido")
+        return
+    }
+    // lógica principal aquí, sin anidamiento
+}
+```
+
+---
+
+## Sendable para tipos compartidos entre actores
+
+Swift 6 hace obligatoria la conformidad con `Sendable` para tipos que cruzan
+fronteras de concurrencia. Los tipos que no son `Sendable` no pueden pasarse
+entre `Task`s o actores sin una copia.
+
+```swift
+// BIEN — struct es Sendable por defecto si todos sus campos lo son
+struct Pedido: Sendable {
+    let id: UUID
+    let total: Decimal
+}
+
+// BIEN — clase Sendable requiere sincronización interna
+final class ConfiguracionGlobal: @unchecked Sendable {
+    private let lock = NSLock()
+    private var _configuracion: [String: String] = [:]
+
+    func obtener(_ clave: String) -> String? {
+        lock.withLock { _configuracion[clave] }
+    }
+}
+```
+
+---
+
+## Trailing closures solo para el último parámetro
+
+```swift
+// MAL — trailing closure cuando no es el último parámetro
+UIView.animate(withDuration: 0.3) {
+    self.vista.alpha = 1.0
+} completion: { _ in }
+
+// BIEN — trailing closure solo cuando es el último argumento y mejora la legibilidad
+UIView.animate(withDuration: 0.3, animations: {
+    self.vista.alpha = 1.0
+}) { _ in
+    // completion
+}
+
+// BIEN — trailing closure natural para el último parámetro
+items.filter { $0.esActivo }
+     .map { $0.nombre }
+```
+
+---
+
+## Límites de tamaño y nombres
+
+- Funciones: máxima **40 líneas** (sin contar líneas en blanco y comentarios)
+- Parámetros: máximo **4**. Si se necesitan más, usar un struct de parámetros
+- Tipos (struct/class/enum): `UpperCamelCase`
+- Funciones, propiedades y variables: `lowerCamelCase`
+- Constantes: `lowerCamelCase` (Swift no usa SCREAMING_CASE)
+
+---
+
+## Checklist de estilo Swift antes de abrir PR
+
+- [ ] SwiftFormat aplicado sin errores
+- [ ] SwiftLint pasa con configuración del proyecto
+- [ ] Sin `var` donde `let` es suficiente
+- [ ] `struct` para modelos de datos; `class` justificado cuando se usa
+- [ ] Sin `if let` anidados: usar `guard let` con early return
+- [ ] Concurrencia con `async/await`; actores para estado compartido
+- [ ] Sin force unwrap `!` en `src/` (solo en tests con justificación)
+- [ ] Funciones <= 40 líneas

package/reglas/lenguajes/swift/hooks.md

@@ -0,0 +1,257 @@
+# Regla: Hooks de Calidad para Swift
+
+Esta regla define las verificaciones automáticas obligatorias que corren en cada
+commit y merge para código Swift. SwiftFormat y SwiftLint detectan en segundos
+errores que de otro modo llegan a code review o a producción.
+
+---
+
+## SwiftFormat antes de commit (pre-commit hook)
+
+SwiftFormat aplica formato de manera determinista. El hook corre en modo de formato
+y falla si el archivo queda con cambios sin stagear (significa que había diferencias).
+
+```bash
+#!/bin/sh
+# .git/hooks/pre-commit
+
+SWIFT_FILES=$(git diff --cached --name-only | grep "\.swift$")
+
+if [ -z "$SWIFT_FILES" ]; then
+    exit 0
+fi
+
+echo "Ejecutando SwiftFormat..."
+echo "$SWIFT_FILES" | xargs swiftformat --config .swiftformat
+
+# Si SwiftFormat modificó archivos, abortar para que el dev revise
+if ! git diff --quiet; then
+    echo "SwiftFormat modificó archivos. Revisa los cambios y vuelve a hacer commit:"
+    git diff --name-only
+    exit 1
+fi
+echo "SwiftFormat: OK"
+```
+
+Configuración base `.swiftformat` del proyecto:
+```
+--indent 4
+--linebreaks lf
+--maxwidth 120
+--wraparguments before-first
+--closingparen balanced
+--semicolons never
+--trailingCommas always
+--importgrouping testable-bottom
+```
+
+---
+
+## SwiftLint --strict antes de commit
+
+```bash
+# Pre-commit — continua del hook anterior
+echo "Ejecutando SwiftLint..."
+echo "$SWIFT_FILES" | xargs swiftlint lint --strict --config .swiftlint.yml
+
+if [ $? -ne 0 ]; then
+    echo "SwiftLint encontro violaciones. Corregir antes de hacer commit."
+    exit 1
+fi
+echo "SwiftLint: OK"
+```
+
+Configuración crítica en `.swiftlint.yml` que NUNCA debe desactivarse:
+```yaml
+opt_in_rules:
+  - force_unwrapping          # detecta ! en producción
+  - force_try                 # detecta try! en producción
+  - force_cast                # detecta as! en producción
+  - implicitly_unwrapped_optional
+  - discouraged_optional_boolean
+
+custom_rules:
+  no_print:
+    name: "No print en producción"
+    regex: '^\s*print\('
+    message: "Usar Logger del proyecto en lugar de print()"
+    severity: error
+    excluded: ".*Tests.*\\.swift"
+```
+
+---
+
+## swift build antes de merge (CI obligatorio)
+
+El build completo con tests corre en CI antes de aprobar cualquier merge.
+El pipeline bloqueante en GitHub Actions:
+
+```yaml
+# .github/workflows/ci.yml
+name: CI Swift
+
+on: [push, pull_request]
+
+jobs:
+  build-and-test:
+    runs-on: macos-14
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: SwiftLint
+        run: swiftlint lint --strict
+
+      - name: SwiftFormat (verificación)
+        run: swiftformat --lint .
+
+      - name: Build
+        run: xcodebuild build-for-testing
+          -scheme MiApp
+          -destination 'platform=iOS Simulator,name=iPhone 15'
+
+      - name: Tests
+        run: xcodebuild test-without-building
+          -scheme MiApp
+          -destination 'platform=iOS Simulator,name=iPhone 15'
+          -enableCodeCoverage YES
+
+      - name: Verificar cobertura
+        run: |
+          COBERTURA=$(xcrun xccov view --report DerivedData/Logs/Test/*.xcresult --json | python3 -c "import json,sys; d=json.load(sys.stdin); print(d['lineCoverage']*100)")
+          echo "Cobertura: $COBERTURA%"
+          python3 -c "import sys; sys.exit(0 if float('$COBERTURA') >= 80 else 1)"
+```
+
+---
+
+## Detección de print() en código no-test
+
+`print()` en producción contamina la consola y puede exponer datos sensibles en logs.
+Solo se permite en archivos que contienen `Tests` en su nombre o ruta.
+
+```bash
+# Script de detección — integrado en pre-commit
+SWIFT_MAIN=$(git diff --cached --name-only | grep "\.swift$" | grep -v -i "test")
+
+if [ -n "$SWIFT_MAIN" ]; then
+    MATCHES=$(echo "$SWIFT_MAIN" | xargs grep -En "^\s*print\(" 2>/dev/null)
+    if [ -n "$MATCHES" ]; then
+        echo "ERROR: print() encontrado en código de producción:"
+        echo "$MATCHES"
+        echo "Usar Logger o os.log en lugar de print()."
+        exit 1
+    fi
+fi
+```
+
+Alternativa recomendada al `print()`:
+```swift
+import os.log
+
+private let logger = Logger(subsystem: "com.miapp.pedidos", category: "PedidoViewModel")
+
+// En lugar de print("Pedido cargado: \(pedido.id)")
+logger.info("Pedido cargado: \(pedido.id, privacy: .public)")
+```
+
+---
+
+## Detección de force unwrap (!) en src/
+
+El force unwrap `!` en producción es equivalente al `!!` de Kotlin: una excepción
+garantizada en el peor momento posible.
+
+```bash
+# Detección de ! en archivos de producción (excluir tests y comentarios)
+SWIFT_MAIN=$(git diff --cached --name-only | grep "\.swift$" | grep -v -i "test")
+
+if [ -n "$SWIFT_MAIN" ]; then
+    # Detectar: variable!, as!, try! — excluir !=, !important, comentarios
+    MATCHES=$(echo "$SWIFT_MAIN" | xargs grep -En "[a-zA-Z0-9_\)]\![^=]|as\!|try\!" 2>/dev/null \
+        | grep -v "//.*!" \
+        | grep -v "^\s*//" )
+    if [ -n "$MATCHES" ]; then
+        echo "ERROR: Force unwrap (!) encontrado en código de producción:"
+        echo "$MATCHES"
+        echo "Usar guard let, if let, o try? con manejo explícito del nil/error."
+        exit 1
+    fi
+fi
+```
+
+SwiftLint con `force_unwrapping`, `force_try` y `force_cast` en `opt_in_rules`
+también detecta estos casos.
+
+---
+
+## Detección de fatalError en código no-test
+
+`fatalError()` termina la app inmediatamente. Solo se acepta en:
+- Tests (para indicar setup incorrecto)
+- Casos que son literalmente imposibles y son errores de programación (no errores de runtime)
+
+```bash
+# Detección de fatalError en producción
+SWIFT_MAIN=$(git diff --cached --name-only | grep "\.swift$" | grep -v -i "test")
+
+if [ -n "$SWIFT_MAIN" ]; then
+    MATCHES=$(echo "$SWIFT_MAIN" | xargs grep -En "fatalError\(" 2>/dev/null | grep -v "//.*fatalError")
+    if [ -n "$MATCHES" ]; then
+        echo "ADVERTENCIA: fatalError() encontrado en código de producción:"
+        echo "$MATCHES"
+        echo "Considerar lanzar un error tipado o usar preconditionFailure() con justificación."
+        # exit 1 — cambiar a error si el proyecto tiene política estricta
+    fi
+fi
+```
+
+---
+
+## Configuración de pre-commit con pre-commit framework
+
+Para equipos que prefieren una herramienta declarativa:
+
+```yaml
+# .pre-commit-config.yaml
+repos:
+  - repo: local
+    hooks:
+      - id: swiftformat
+        name: SwiftFormat
+        entry: swiftformat
+        language: system
+        types: [swift]
+        args: [--config, .swiftformat]
+
+      - id: swiftlint
+        name: SwiftLint
+        entry: swiftlint
+        language: system
+        types: [swift]
+        args: [lint, --strict, --config, .swiftlint.yml]
+
+      - id: no-print
+        name: No print() en producción
+        entry: bash -c 'grep -En "^\s*print\(" "$@" | grep -v "test" && exit 1 || exit 0'
+        language: system
+        types: [swift]
+
+      - id: no-force-unwrap
+        name: No force unwrap en producción
+        entry: bash -c 'grep -En "[a-zA-Z0-9_\)]\![^=]" "$@" | grep -v "test" | grep -v "//.*!" && exit 1 || exit 0'
+        language: system
+        types: [swift]
+```
+
+---
+
+## Checklist de hooks Swift
+
+- [ ] SwiftFormat configurado y corriendo en pre-commit
+- [ ] SwiftLint con `--strict` en pre-commit
+- [ ] `force_unwrapping`, `force_try`, `force_cast` en `opt_in_rules` de SwiftLint
+- [ ] swift build y tests corren en CI antes de aprobar merge
+- [ ] Detección de `print()` activa para `src/` (excluye tests)
+- [ ] Detección de `!` (force unwrap) activa para `src/`
+- [ ] Detección de `fatalError()` activa (al menos como advertencia)
+- [ ] pre-commit o lefthook instalado y versionado en el repositorio