Fix file name sanitization for generic types with invalid characters (#31)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: mackoj <661647+mackoj@users.noreply.github.com>

Author: Copilot

Sources/SwiftSnapshotCore/PathResolver.swift

@@ -136,9 +136,58 @@ enum PathResolver {
       finalFileName = fileName.hasSuffix(".swift") ? fileName : "\(fileName).swift"
     } else {
       // Default: TypeName+VariableName.swift
-      finalFileName = "\(typeName)+\(variableName).swift"
+      // Sanitize the type name to ensure it's a valid file name
+      let sanitizedTypeName = sanitizeFileName(typeName)
+      finalFileName = "\(sanitizedTypeName)+\(variableName).swift"
     }
 
     return outputDirectory.appendingPathComponent(finalFileName)
   }
+  
+  /// Sanitize a string to be a valid file name component
+  ///
+  /// Replaces characters that are invalid in file names with underscores.
+  /// This is particularly important for generic types like `User<T>` or `Dictionary<String, Int>`.
+  ///
+  /// ## Invalid Characters
+  ///
+  /// The following characters are replaced with underscores:
+  /// - Angle brackets: `<` `>`
+  /// - Slashes: `/` `\`
+  /// - Colons: `:`
+  /// - Asterisks: `*`
+  /// - Question marks: `?`
+  /// - Quotes: `"` `'`
+  /// - Pipe: `|`
+  /// - Other special characters that might be invalid on some filesystems
+  ///
+  /// ## Examples
+  ///
+  /// ```swift
+  /// sanitizeFileName("User<Kakou>")
+  /// // Returns: "User_Kakou_"
+  ///
+  /// sanitizeFileName("Dictionary<String, Int>")
+  /// // Returns: "Dictionary_String__Int_"
+  ///
+  /// sanitizeFileName("Array<[String: Int]>")
+  /// // Returns: "Array__String__Int__"
+  /// ```
+  ///
+  /// - Parameter name: The string to sanitize for use as a file name
+  /// - Returns: A sanitized string safe for use in file names
+  private static func sanitizeFileName(_ name: String) -> String {
+    // Characters that are typically invalid or problematic in file names across platforms
+    let invalidChars: Set<Character> = ["<", ">", ":", "\"", "/", "\\", "|", "?", "*", ",", " "]
+    
+    let sanitized = name.map { char -> Character in
+      if invalidChars.contains(char) {
+        return "_"
+      } else {
+        return char
+      }
+    }
+    
+    return String(sanitized)
+  }
 }

Tests/SwiftSnapshotTests/IntegrationTests.swift

@@ -382,5 +382,64 @@ extension SnapshotTests {
       """#
     }
     }
+    
+    // MARK: - Generic Types Test
+    
+    @Test func genericTypesWithValidFileName() throws {
+      struct Kakou: Codable {
+        let toto: String
+        let tata: Val
+        enum Val: Codable {
+          case a, b, c
+        }
+      }
+      
+      struct User<T: Codable>: Codable {
+        let id: Int
+        let name: String
+        let some: [T]
+      }
+      
+      let mockData = [
+        Kakou(toto: "hello", tata: .b),
+        Kakou(toto: "world", tata: .c),
+      ]
+      
+      let user = User(id: 42, name: "Alice", some: mockData)
+      
+      // Test that the file export works and creates a valid file name
+      let tempDir = FileManager.default.temporaryDirectory
+        .appendingPathComponent("SwiftSnapshotTests")
+        .appendingPathComponent(UUID().uuidString)
+      
+      let url = try SwiftSnapshotRuntime.export(
+        instance: user,
+        variableName: "mock",
+        outputBasePath: tempDir.path,
+        header: "/// Test HEADER",
+        context: "This is for testing."
+      )
+      
+      // Cleanup
+      defer { try? FileManager.default.removeItem(at: tempDir) }
+      
+      // Verify file exists
+      #expect(FileManager.default.fileExists(atPath: url.path))
+      
+      // Verify file name is sanitized (no < or > characters)
+      let fileName = url.lastPathComponent
+      #expect(!fileName.contains("<"))
+      #expect(!fileName.contains(">"))
+      
+      // The file name should be sanitized to User_Kakou_+mock.swift
+      #expect(fileName == "User_Kakou_+mock.swift")
+      
+      // Verify content is valid Swift code
+      let content = try String(contentsOf: url, encoding: .utf8)
+      #expect(content.contains("/// Test HEADER"))
+      #expect(content.contains("This is for testing."))
+      #expect(content.contains("static let mock"))
+      #expect(content.contains("id: 42"))
+    }
   }
 }

Tests/SwiftSnapshotTests/PathResolverTests.swift

@@ -135,7 +135,8 @@ extension SnapshotTests {
         outputDirectory: outputDir
       )
 
-      #expect(result1.lastPathComponent == "Array<String>+myArray.swift")
+      // Angle brackets should be sanitized
+      #expect(result1.lastPathComponent == "Array_String_+myArray.swift")
 
       let result2 = PathResolver.resolveFilePath(
         typeName: "Dictionary<String, Int>",
@@ -144,7 +145,56 @@ extension SnapshotTests {
         outputDirectory: outputDir
       )
 
-      #expect(result2.lastPathComponent == "Dictionary<String, Int>+myDict.swift")
+      // Angle brackets and commas should be sanitized
+      #expect(result2.lastPathComponent == "Dictionary_String__Int_+myDict.swift")
+    }
+    
+    /// Test that generic type names are properly sanitized
+    @Test func resolveFilePathWithGenericTypes() {
+      let outputDir = URL(fileURLWithPath: "/tmp/snapshots")
+      
+      // Test User<Kakou>
+      let result1 = PathResolver.resolveFilePath(
+        typeName: "User<Kakou>",
+        variableName: "mock",
+        fileName: nil,
+        outputDirectory: outputDir
+      )
+      #expect(result1.lastPathComponent == "User_Kakou_+mock.swift")
+      
+      // Test nested generics
+      let result2 = PathResolver.resolveFilePath(
+        typeName: "Array<Dictionary<String, Int>>",
+        variableName: "data",
+        fileName: nil,
+        outputDirectory: outputDir
+      )
+      #expect(result2.lastPathComponent == "Array_Dictionary_String__Int__+data.swift")
+      
+      // Test with spaces
+      let result3 = PathResolver.resolveFilePath(
+        typeName: "Optional<User Model>",
+        variableName: "user",
+        fileName: nil,
+        outputDirectory: outputDir
+      )
+      #expect(result3.lastPathComponent == "Optional_User_Model_+user.swift")
+    }
+    
+    /// Test that custom fileName is not sanitized (user provided)
+    @Test func customFileNameNotSanitized() {
+      let outputDir = URL(fileURLWithPath: "/tmp/snapshots")
+      
+      // When user provides custom fileName, it should be used as-is
+      let result = PathResolver.resolveFilePath(
+        typeName: "User<Kakou>",
+        variableName: "mock",
+        fileName: "CustomFixture",
+        outputDirectory: outputDir
+      )
+      
+      // Custom file name should not trigger sanitization
+      #expect(result.lastPathComponent == "CustomFixture.swift")
     }
 
     /// Test priority order: explicit > global > env > default