Merge pull request #97 from onevcat/codex/pr93-followup-generated-asset-symbols

Clarify and validate generated Objective-C asset symbol support

Author: onevcat

Sources/FengNiaoKit/Extensions.swift

@@ -59,9 +59,23 @@ extension String {
 
     /// Convert resource name (snake/kebab case) to generated Swift asset symbol such as `.icChatWhite`.
     var generatedAssetSymbolKey: String {
-        if isEmpty { return "." }
-        var ret = "."
-        var shouldUpperNext = false
+        return convertToCamelCase(prefix: ".", uppercaseFirst: false)
+    }
+    
+    /// Convert resource name (snake/kebab case) to generated Objective-C asset symbol such as `ACImageNameIcFlag`.
+    /// Example: "ic_flag" -> "ACImageNameIcFlag"
+    var objcGeneratedAssetSymbolKey: String {
+        return convertToCamelCase(prefix: "ACImageName", uppercaseFirst: true)
+    }
+    
+    /// Convert resource name (snake/kebab case) to camel case with optional prefix.
+    /// - Parameters:
+    ///   - prefix: The prefix to prepend to the result
+    ///   - uppercaseFirst: Whether the first character after prefix should be uppercase
+    private func convertToCamelCase(prefix: String, uppercaseFirst: Bool) -> String {
+        if isEmpty { return prefix }
+        var ret = prefix
+        var shouldUpperNext = uppercaseFirst
         for character in self {
             switch character {
             case "-", "_", " ":

Sources/FengNiaoKit/FengNiao.swift

@@ -125,8 +125,21 @@ public struct FengNiao {
         let allResources = allResourceFiles()
         let usedNames = allUsedStringNames()
         let memberAccessUsedNames = allUsedMemberAccessNames()
+        
+        // Generated asset symbols are an additional conservative usage signal.
+        // Swift uses `.icFlag`, while Objective-C image symbols use `ACImageNameIcFlag`.
         let resourcesUsedByGeneratedSymbols = Set(
-            allResources.keys.filter { memberAccessUsedNames.contains($0.generatedAssetSymbolKey) }
+            allResources.keys.filter { resourceKey in
+                let swiftSymbolKey = resourceKey.generatedAssetSymbolKey
+                if memberAccessUsedNames.contains(swiftSymbolKey) {
+                    return true
+                }
+                let objcImageSymbolKey = resourceKey.objcGeneratedAssetSymbolKey
+                if memberAccessUsedNames.contains(objcImageSymbolKey) {
+                    return true
+                }
+                return false
+            }
         )
         let combinedUsedNames = usedNames.union(resourcesUsedByGeneratedSymbols)
 
@@ -216,7 +229,8 @@ public struct FengNiao {
     }
 
     func allUsedMemberAccessNames() -> Set<String> {
-        guard searchInFileExtensions.contains("swift") else {
+        let memberAccessExtensions: Set<String> = ["swift", "m", "mm", "h"]
+        guard searchInFileExtensions.contains(where: { memberAccessExtensions.contains($0) }) else {
             return []
         }
         return usedMemberAccessNames(at: projectPath)
@@ -271,7 +285,9 @@ public struct FengNiao {
             return []
         }
 
-        let searchRule = SwiftMemberAccessSearchRule()
+        let memberAccessExtensions: Set<String> = ["swift", "m", "mm", "h"]
+        let swiftSearchRule = SwiftMemberAccessSearchRule()
+        let objcSearchRule = ObjCMemberAccessSearchRule()
         var result = Set<String>()
         for subPath in subPaths {
             if subPath.lastComponent.hasPrefix(".") {
@@ -285,12 +301,23 @@ public struct FengNiao {
             if subPath.isDirectory {
                 result.formUnion(usedMemberAccessNames(at: subPath))
             } else {
-                guard (subPath.extension ?? "") == "swift" else {
+                let fileExt = subPath.extension ?? ""
+                guard searchInFileExtensions.contains(fileExt), memberAccessExtensions.contains(fileExt) else {
                     continue
                 }
 
                 let content = (try? subPath.read()) ?? ""
-                result.formUnion(searchRule.search(in: content))
+                
+                switch fileExt {
+                case "swift":
+                    result.formUnion(swiftSearchRule.search(in: content))
+                case "m", "mm", "h":
+                    // Scan headers conservatively as well, since projects may wrap generated
+                    // asset symbols in macros or inline helpers that are later imported into Swift.
+                    result.formUnion(objcSearchRule.search(in: content))
+                default:
+                    break
+                }
             }
         }
 

Sources/FengNiaoKit/FileSearchRule.swift

@@ -80,7 +80,7 @@ struct SwiftMemberAccessSearchRule: FileSearchRule {
     func search(in content: String) -> Set<String> {
         let nsstring = NSString(string: content)
         var result = Set<String>()
-        let pattern = #"(?<![A-Za-z0-9_])(UIImage|UIColor|NSImage|NSColor|Image|Color)?\s*\.\s*([A-Za-z0-9_]+)"#
+        let pattern = #"(?<![A-Za-z0-9_])(ImageResource|UIImage|UIColor|NSImage|NSColor|Image|Color)?\s*\.\s*([A-Za-z0-9_]+)"#
         let reg = try! NSRegularExpression(pattern: pattern, options: [])
         let matches = reg.matches(in: content, options: [], range: content.fullRange)
         for match in matches {
@@ -93,6 +93,35 @@ struct SwiftMemberAccessSearchRule: FileSearchRule {
     }
 }
 
+/// Search for generated Objective-C image asset symbols such as `ACImageNameIcFlag`.
+/// Example: "ic_flag.png" -> "ACImageNameIcFlag"
+struct ObjCMemberAccessSearchRule: FileSearchRule {
+    func search(in content: String) -> Set<String> {
+        let nsstring = NSString(string: content)
+        var result = Set<String>()
+        
+        result.formUnion(matchSymbols(in: content, prefix: "ACImageName", nsstring: nsstring))
+        
+        return result
+    }
+    
+    private func matchSymbols(in content: String, prefix: String, nsstring: NSString) -> Set<String> {
+        var result = Set<String>()
+        // Escape the prefix for use in regex pattern
+        let escapedPrefix = NSRegularExpression.escapedPattern(for: prefix)
+        let pattern = "\(escapedPrefix)([A-Z][a-zA-Z0-9]*)"
+        let reg = try! NSRegularExpression(pattern: pattern, options: [])
+        let matches = reg.matches(in: content, options: [], range: content.fullRange)
+        for match in matches {
+            let identifierRange = match.range(at: 1)
+            guard identifierRange.location != NSNotFound else { continue }
+            let identifier = nsstring.substring(with: identifierRange)
+            result.insert("\(prefix)\(identifier)")
+        }
+        return result
+    }
+}
+
 struct XibImageSearchRule: RegPatternSearchRule {
     let extensions = [String]()
     let patterns = ["image name=\"(.*?)\"", "image=\"(.*?)\"", "value=\"(.*?)\""]

Tests/FengNiaoKitTests/GeneratedAssetSymbolTests.swift

@@ -20,4 +20,34 @@ struct GeneratedAssetSymbolTests {
         let expected: Set<String> = ["ic_unused.png"]
         #expect(fileNames == expected)
     }
+
+    @Test("treats generated Objective-C asset symbols in implementation files as usage")
+    func treatsGeneratedObjectiveCAssetSymbolsAsUsage() throws {
+        let project = fixtures + "GeneratedAssetSymbolObjC"
+        let fengniao = FengNiao(
+            projectPath: project.string,
+            excludedPaths: [],
+            resourceExtensions: ["png"],
+            searchInFileExtensions: ["m"]
+        )
+        let result = try fengniao.unusedFiles()
+        let fileNames = Set(result.map { $0.fileName })
+        let expected: Set<String> = ["ic_unused.png"]
+        #expect(fileNames == expected)
+    }
+
+    @Test("treats generated Objective-C asset symbols in headers as usage conservatively")
+    func treatsGeneratedObjectiveCAssetSymbolsInHeadersAsUsageConservatively() throws {
+        let project = fixtures + "GeneratedAssetSymbolHeader"
+        let fengniao = FengNiao(
+            projectPath: project.string,
+            excludedPaths: [],
+            resourceExtensions: ["png"],
+            searchInFileExtensions: ["h"]
+        )
+        let result = try fengniao.unusedFiles()
+        let fileNames = Set(result.map { $0.fileName })
+        let expected: Set<String> = ["ic_unused.png"]
+        #expect(fileNames == expected)
+    }
 }

Tests/FengNiaoKitTests/SearchRuleTests.swift

@@ -85,12 +85,13 @@ struct SearchRuleTests {
         let searcher = SwiftMemberAccessSearchRule()
         let content = """
         let flag = UIImage.icFlag
+        let flag1 = ImageResource.icFlag1
         let highlighted: UIImage = .icFlagHighlighted
         let legacy = NSImage .icFlagSecondary
         let accent = Color .customAccent
         """
         let result = searcher.search(in: content)
-        let expected: Set<String> = [".icFlag", ".icFlagHighlighted", ".icFlagSecondary", ".customAccent"]
+        let expected: Set<String> = [".icFlag", ".icFlag1", ".icFlagHighlighted", ".icFlagSecondary", ".customAccent"]
         #expect(result == expected)
     }
 
@@ -134,4 +135,33 @@ struct SearchRuleTests {
         let result = searcher.search(in: content)
         #expect(result.isEmpty)
     }
+
+    @Test("Objective-C member access rule applies to generated symbols")
+    func objcMemberAccessRuleAppliesToGeneratedSymbols() {
+        let searcher = ObjCMemberAccessSearchRule()
+        let content = """
+        UIImage *flag = [UIImage imageNamed:ACImageNameIcFlag];
+        UIImage *highlighted = [UIImage imageNamed:ACImageNameIcFlagHighlighted];
+        NSImage *legacy = [NSImage imageNamed:ACImageNameIcFlagSecondary];
+        NSString *name = ACImageNameIcFlag;
+        """
+        let result = searcher.search(in: content)
+        let expected: Set<String> = [
+            "ACImageNameIcFlag",
+            "ACImageNameIcFlagHighlighted",
+            "ACImageNameIcFlagSecondary",
+        ]
+        #expect(result == expected)
+    }
+
+    @Test("Objective-C member access rule ignores regular constants")
+    func objcMemberAccessRuleIgnoresRegularConstants() {
+        let searcher = ObjCMemberAccessSearchRule()
+        let content = """
+        NSString *name = kImageName;
+        NSString *other = SomeOtherConstant;
+        """
+        let result = searcher.search(in: content)
+        #expect(result.isEmpty)
+    }
 }

Tests/FengNiaoKitTests/StringExtensionsTests.swift

@@ -41,4 +41,21 @@ struct StringExtensionsTests {
         ]
         #expect(images.map { $0.generatedAssetSymbolKey } == expected)
     }
+    
+    @Test("objcGeneratedAssetSymbolKey converts to Objective-C format")
+    func objcGeneratedAssetSymbolKeyConvertsToObjectiveCFormat() {
+        let images = [
+            "ic_chat_white_24px",
+            "ic-chat_white_24 px",
+            "iC-ChAt_whIte_24 pX",
+            "ICCHATWHITE",
+        ]
+        let expected = [
+            "ACImageNameIcChatWhite24Px",
+            "ACImageNameIcChatWhite24Px",
+            "ACImageNameICChAtWhIte24PX",
+            "ACImageNameICCHATWHITE",
+        ]
+        #expect(images.map { $0.objcGeneratedAssetSymbolKey } == expected)
+    }
 }

Tests/Fixtures/GeneratedAssetSymbolHeader/AssetSymbols.h

@@ -0,0 +1,7 @@
+#import <UIKit/UIKit.h>
+
+#define FNFlagAssetName ACImageNameIcFlag
+
+NS_INLINE UIImage *FNFlagImage(void) {
+    return [UIImage imageNamed:ACImageNameIcFlag];
+}

Tests/Fixtures/GeneratedAssetSymbolHeader/ic_flag.png

@@ -0,0 +1,5 @@
+#import <UIKit/UIKit.h>
+
+void configureFlagView(UIImageView *imageView) {
+    imageView.image = [UIImage imageNamed:ACImageNameIcFlag];
+}