cocoapods-privacy 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 149efd9549824e388ee859167394477eabe82e7a715ef49ba43b195d9b501746
-  data.tar.gz: 2949e52fffbefec5c2cb401711533e8a6e38d7f9cf53a1d19919a794a3a6dc8f
+  metadata.gz: 5cba9b9c9c115fa3aa4ce42e7a16a941ff121244e8293b73ef966d66e83a1d6f
+  data.tar.gz: dc65d1598e50bcda55d989d70e515e3197540d43e952d2fa4d3941010f585080
 SHA512:
-  metadata.gz: ff8fbcab1c042ea1bf24e503d75b593f7f6a2adc59836cd822ed5e2ddf58f6a1e3efc91cd7c8e79d8647f42936d8e21c215d25a9c943a940df86e4ed090149c9
-  data.tar.gz: 5037a9f32b471b8ec69172389969a568a7f63adc31f0278379a5d048828eaaa92d5457082809723db438ef39a155a61cbdac8dbf998e5e91b92dcf412ff5d09d
+  metadata.gz: c72e3521078489bed4c1e4dfea1f9cf229d5ff9a315750bb7043106078225c8e976894306a8997af365b418a6c03132b837c6364895f12d8e7aae5a920db1a5f
+  data.tar.gz: 4e2e36942669c75e9ff98be1224989bd4682830cf25ca2c6763b57fb0fd24ded722909e090389aeaf5a76e3a831c68f629945594d94c4783a58857fd655d1d19

data/lib/cocoapods-privacy/confuse/ConfuseHunter.rb

@@ -45,7 +45,7 @@ module Confuse
           func = "public extension #{key} {\n" + values.map { |value|
             value.split("\n").map { |line| "  #{line}" }.join("\n")  # 每行前加四个空格
           }.join("\n\n") + "\n}"
-        }.join("\n")
+        }.join("\n\n")
         confuse_func_content = funcs
         puts "混淆(扩展):\n 文件:#{swift_confuse_file_path}\n 内容👇:\n#{confuse_func_content}"
 
@@ -104,7 +104,7 @@ module Confuse
         swift_extension_funcBody_map = {}
 
         #oc 暴露给swift 的扩展名称
-        swift_extension = ""
+        swift_extension = []
 
         # 段注释和单行注释标志
         in_block_comment = false
@@ -177,48 +177,92 @@ module Confuse
           if !in_block_comment && !in_line_comment
 
               ###----- 处理oc ------
-              # 查找并处理注解：__attribute__((annotate("BB_?Confuse:xxx")))
-              #.*?: 匹配任意字符（包括冒号），但它会尽量少匹配直到遇到冒号为止。
-              #.*? 匹配冒号后面的一些字符（任意字符，直到遇到下一个双引号）。
-              #这样可以确保匹配的字符串中至少包含一个冒号。
-              line_scrub.scan(/__attribute__\(\(annotate\("(.*?:.*?)"\)\)\)/) do |match|
-                # # 将注解内容按逗号分割功能，并去重
-                  commands = match.first.split(',').map(&:strip)
-                  commands.map do |commandInfo| 
-                    puts commandInfo
-                    commandKeyAndValue = commandInfo.split(':')
-                    commandKey =  commandKeyAndValue.first
-                    commandValue =  commandKeyAndValue.last
-                    if commandKey && commandKey =~ /BB_?Confuse/
-                      swift_extension = commandValue
-                    end
+              #### 检测BBConfuseOCToSwift("xxxx") 用来处理oc函数混淆暴露给swift
+              line_scrub.scan(/^BBConfuseOCToSwift\(\"(.*?)\"\)/) do |match|
+                  literals = match.first.split(',').map(&:strip)
+                  unless literals.empty?
+                    swift_extension = literals
                   end
+              end
+
+              ### 检测BBConfuseOCClass("xxxx") 用来处理oc 类混淆
+              line_scrub.gsub!(/^BBConfuseOCClass\(\"(.*?)\"\)/) do |match|
+                modified = true #开启编辑
+                original_api = $1
+                new_api = encrypted_api([original_api]).first
+                puts "asasd = #{new_api} "
+                "BBConfuseOCClass(\"#{new_api}\")"
+              end
 
-                  # new_parts = encrypted_api(apis)
 
-                  # apis.each_with_index do |seg, index| 
-                  #   apis_define_map[seg.strip] = new_parts[index]
-                  # end
+              #### 检测BBConfuseOCClass("xxxx") 用来处理oc 类混淆
+              # line_scrub.scan(/^BBConfuseOCClass\(\"(.*?)\"\)/) do |match|
+              #   puts "match = #{match}"
+              #     apis = [match.first]
+              #      puts "apis = #{apis}"
+              #     new_parts = encrypted_api(apis)
+              #     apis.each_with_index do |seg, index| 
+              #       apis_define_map[seg.strip] = new_parts[index]
+              #     end
+              # end
+
+              # @property (nonatomic, assign) BOOL coldLaunch BBConfuseOCProperty;
+              #### 检测@protperty(xxxx)mmm *nnn BBConfuseOCProperty 用来处理oc 属性混淆
+              line_scrub.scan(/^@property\s*\((.*?)\)\s*(\w+)\s*([\*&]?)\s*(\w+)\s*BBConfuseOCProperty/) do |match|
+                puts "BBConfuseOCProperty = #{match}"
+                is_nullable = match.first.include?("nullable") || match.first.include?("weak")
+                return_type = match.second + match[2]
+                property_name = match[3]
+                apis = [property_name]
+                new_parts = encrypted_api(apis)
+         
+                if !swift_extension.empty? && return_type && !return_type.empty?
+                  swift_return_type = ConfuseUtils.convert_oc_type_to_swift(return_type)
+                  swift_property_body = SwiftCallAssembly.assemblyProperty(property_name,new_parts.first,swift_return_type,is_nullable)
+
+                  swift_extension.each do |extension|
+                    swift_extension_funcBody_map[extension] ||= []
+                    swift_extension_funcBody_map[extension].push(swift_property_body)
+                  end
+                end
 
-                  # puts "__attribute__ = #{match}"
+                apis.each_with_index do |seg, index| 
+                    apis_define_map[seg.strip] = new_parts[index]
+                end
               end
 
-              # 查找并处理注解：__attribute__((annotate("xxx")))
-              # @regex = /^[+-]\s*\(\s*([^$]+)\s*\**\s*\)\s*(.+)/
-              line_scrub.scan(/(^[-+]\s*\(.*?\)\s*(\w+)\s*([\w\s]+))\s*__attribute__\(\(annotate\(/) do |match|
+              #### BBConfuseOCFunc 用来处理oc 函数混淆
+              # ^	匹配行首	+ (BOOL)
+              # [-+]	匹配 + 或 - 符号（ObjC 方法声明开头）	+
+              # \s*	匹配 0 个或多个空白字符	空格
+              # \([\w\s\*]+\)	匹配一对圆括号里的类型声明，含字母、空格、* 指针符	(BOOL) / (NSString *)
+              # \s*	匹配 0 个或多个空白字符	空格
+              # (\w+)	捕获组 1：匹配方法名（只匹配到冒号前）	uxxx_BB_Confuse_BBMUserCenter
+              # \s*	匹配 0 个或多个空白字符	空格
+              # (.*?)	捕获组 2：匹配“方法声明后到 __attribute__ 前的所有内容”，但用非贪婪方式，遇到 __attribute__ 就停	:(NSString *)name tip:(BOOL)ret
+              # \s*__attribute__\(\(annotate\(	匹配固定字符串 __att
+              regular = ConfuseUtils.oc_func_regular(line_scrub,false)
+              if regular
+                regular = /#{regular}\s*BBConfuseOCFunc/
+                line_scrub.scan(regular) do |match|
                   apis = [match.second]
                   new_parts = encrypted_api(apis)
+                  funcStr = match.first.sub(';','').sub(/BBConfuseOCFunc.*/, '')
+                  is_nullable, return_type, swift_method_declaration ,params = ObjCMethodAPIConverter.convert(funcStr)
 
-                  funcStr = match.first.sub(';','').sub(/__attribute__\(\(annotate\(["][^"]*["]\)\)\).*/, '')
-                  swift_method_declaration,params = ObjCMethodAPIConverter.convert(funcStr)
                   if !swift_extension.empty? && swift_method_declaration && !swift_method_declaration.empty?
-                    swift_func_body = SwiftCallAssembly.assembly(new_parts.first,swift_method_declaration,params)
-                    swift_extension_funcBody_map[swift_extension] ||= []
-                    swift_extension_funcBody_map[swift_extension].push(swift_func_body)
+                    swift_func_body = SwiftCallAssembly.assembly(new_parts.first, swift_method_declaration, params, is_nullable, return_type)
+
+                    swift_extension.each do |extension|
+                      swift_extension_funcBody_map[extension] ||= []
+                      swift_extension_funcBody_map[extension].push(swift_func_body)
+                    end
                   end
+
                   apis.each_with_index do |seg, index| 
                     apis_define_map[seg.strip] = new_parts[index]
                   end
+                end
               end
 
               ###----- 处理swift 类 ------
@@ -281,10 +325,17 @@ module Confuse
               if line_scrub.strip.start_with?(confuse_func_pre_literal)
                 #BBConfuseMixObjc("#selector(abcdefg(in:sencName:))"); asdasagwtrqwetr
       
-
                 #selector(.*?)\)
                 #解析带参数的
-                # line_scrub.gsub!(/#{confuse_func_pre_literal}\(#selector\((.*?)\)\)\);(?:.*?@objc\((\S+)\))?(?:.*?@objc\s*)?/) do |match|
+                # | 部分 | 作用 | 举例 |
+                # |:-------------------------|:------------------------------------------------|:---------------------------------|
+                # | `#{confuse_func_pre_literal}\(` | 匹配你之前定义好的前缀字串（比如 `confuseMethod(`）和一个 `(` | `confuseMethod(` |
+                # | `(?:#selector\((.*?)\)\))?` | **非捕获组**，匹配 `#selector(XXX)`，括号内的 `XXX` 放进 `捕获组1` | `#selector(someMethod)` |
+                # | `(?:"([^"]*:[^"]*)")?` | **可选**，匹配 `:"xxx:xxx"` 格式的字符串，放进 `捕获组2` | `"abc:def"` |
+                # | `\);` | 匹配 `);` |
+                # | `(?:.*?@objc\((\S+)\))?` | **非捕获组**，可选，匹配 `@objc(XXX)`，把 `XXX` 放进 `捕获组3` | `@objc(mySelector)` |
+                # | `(?:.*?@objc\s*)?` | **非捕获组**，可选，匹配剩下一个 `@objc` 没括号的情况 | `@objc` |
+
                 line_scrub.gsub!(/#{confuse_func_pre_literal}\((?:#selector\((.*?)\)\))?(?:"([^"]*:[^"]*)")?\);(?:.*?@objc\((\S+)\))?(?:.*?@objc\s*)?/) do |match|
                   modified = true
                   selector_match = $1
@@ -302,9 +353,15 @@ module Confuse
                 end
 
                 #解析不带参数的
-                # line_scrub.gsub!(/#{confuse_func_pre_literal}\(#selector\(([^\(]+)\)\);(?:.*?@objc\((\S+)\))?(?:.*?@objc\s*)?/) do |match|
+                # | 部分 | 作用 | 举例 |
+                # |:-------------------------------|:--------------------------------------------------|:--------------------------|
+                # | `#{confuse_func_pre_literal}\(` | 匹配你的宏/方法名前缀 + `(`，比如 `confuseMethod(` | `confuseMethod(` |
+                # | `(?:#selector\(([^\(]+)\))?` | **非捕获组**，可选。匹配 `#selector(...)` 里的内容，放进 `捕获组1`，这里用 `([^\(]+)` 匹配**非左括号字符**，直到遇到 `)` | `#selector(doSomething)` → `doSomething` |
+                # | `(?:"([^":]+)")?` | **可选**，匹配 `"xxx"`，但里面不能有 `:` 或 `"`，放进 `捕获组2`。注意这版里不再要求冒号存在，单纯匹配一段字符串 | `"helloWorld"` |
+                # | `\);` | 匹配 `);` 结尾 |
+                # | `(?:.*?@objc\((\S+)\))?` | **非捕获组**，可选。匹配 `@objc(XXX)`，把 `XXX` 放进 `捕获组3`。`(\S+)` 匹配非空白连续字符 | `@objc(doSomethingElse)` |
+                # | `(?:.*?@objc\s*)?` | **非捕获组**，可选。匹配剩下没括号的 `@objc` | `@objc` |
                 line_scrub.gsub!(/#{confuse_func_pre_literal}\((?:#selector\(([^\(]+)\))?(?:"([^":]+)")?\);(?:.*?@objc\((\S+)\))?(?:.*?@objc\s*)?/) do |match|
-                # line_scrub.gsub!(/#{confuse_func_pre_literal}\((#selector\((.*?)\)|"([^"]+)")\);(?:.*?@objc\((\S+)\))?(?:.*?@objc\s*)?/) do |match|
                   modified = true
                   selector_match = $1
                   str_match = $2
@@ -465,9 +522,30 @@ module Confuse
             end
           end
         end
+
+        # 用 apis_define_map 中对应的 value，更新 swift_extension_funcBody_map 中相同 key 的 key, 避免AClass同时定义了类混淆且暴露给swift, swift 扩展使用原先未混淆的类的问题
+        # update_func_body_map_keys!($apis_define_map, $swift_extension_funcBody_map)
+
         return $apis_define_map, $swift_extension_funcBody_map
       end
 
+      # 用 apis_define_map 中对应的 value，更新 swift_extension_funcBody_map 中相同 key 的 key, 避免AClass同时定义了类混淆且暴露给swift, swift 扩展使用原先未混淆的类的问题
+      def update_func_body_map_keys!(apis_define_map, swift_extension_funcBody_map)
+        new_map = {}
+
+        swift_extension_funcBody_map.each do |key, value|
+          if apis_define_map.has_key?(key)
+            confuse_value = apis_define_map[key]
+            new_key = confuse_value
+            new_map[new_key] = value
+          else
+            new_map[key] = value
+          end
+        end
+
+        swift_extension_funcBody_map.replace(new_map)
+      end
+
 
       def encrypted_api(apis)
           encrypted_api = ""

data/lib/cocoapods-privacy/confuse/ConfuseUtils.rb

@@ -18,7 +18,6 @@ module ConfuseUtils
     # xcode工程地址
     def self.project_path
       matching_files = Dir[File.join(Pathname.pwd, '*.xcodeproj')].uniq
-      puts "matching_files = #{matching_files}"
       matching_files.first
     end
 
@@ -104,4 +103,174 @@ module ConfuseUtils
     "#{spaces}#{str}"
   end
 
+  def self.oc_func_regular(str,isCapture = false)
+    if str =~ /^[-+]\s*\(.*?\)/ #为函数
+      num = match_nesting_parentheses_first(str)
+      if isBlockReturn(str) === true #block 返回参数函数
+        if num > 1
+          regular = oc_block_regular(num - 1,isCapture)
+          regular = /(^[-+]#{regular}(\w+)\s*(.+))/
+          return regular
+        end
+      else
+        regular = oc_normal_regular(num - 1,isCapture)
+        regular = /(^[-+]#{regular}(\w+)\s*(.+))/
+        return regular
+      end
+    end
+    return nil
+  end
+
+  def self.match_nesting_parentheses_first(str)
+    stack = []
+    count = 0
+    
+    str.each_char.with_index do |char, idx|
+      if char == '('
+        stack.push(idx)  # 记录左括号的位置
+      elsif char == ')'
+        count += 1
+        stack.pop  # 弹出左括号位置
+        if stack.empty?
+          return count
+        end
+      end
+    end
+    0  # 如果没有匹配到指定数量的括号对，返回 nil
+  end
+
+  def self.isBlockReturn(str)
+    if str =~ /^[-+]\s*\(([^)]*\^.+?)\)/      #block 返回参数函数
+        return true
+    else
+        return false
+    end
+  end
+
+  def self.oc_block_regular(num,isCapture = false)
+    if isCapture == false
+      "\\s*\\((?:[^\\)]+\\)){#{num}}.*?\\)\\s*"
+    else
+      "\\s*\\(((?:[^\\)]+\\)){#{num}}.*?)\\)\\s*"
+    end
+  end
+
+  def self.oc_normal_regular(num,isCapture = false)
+    if isCapture == false
+      "\\s*\\(.*?\\)\\s*"
+    else
+      "\\s*\\((.*?)\\)\\s*"
+    end
+  end
+
+  # Convert the Objective-C return type to a Swift type
+  def self.convert_oc_type_to_swift(return_type)
+    # 去除类型额外的修饰
+    is_nullable = (return_type =~ /\b(__nullable|nullable|_Nullable)\b/)
+    clean_type = return_type.gsub(/\b(__nullable|nullable|_Nullable|__nonnull|nonnull|_Nonnull)\b/, '').strip
+    # 去除类型末尾的指针符号和周围空格，生成基础类型名
+    base_type = clean_type.gsub(/(\w+)\s*\*+\z/, '\1').strip
+       
+    # base_type = return_type
+    # puts  "base_type = #{return_type}"
+
+    case base_type
+    # Foundation 基础类型
+    when "NSString"                    then "String"
+    when "NSMutableString"             then "String" # Swift 中 String 是值类型
+    when "NSArray"                     then "Array<Any>"
+    when "NSMutableArray"              then "Array<Any>"
+    when "NSSet"                       then "Set<Any>"
+    when "NSMutableSet"                then "Set<Any>"
+    when "NSDictionary"                then "Dictionary<AnyHashable, Any>"
+    when "NSMutableDictionary"         then "Dictionary<AnyHashable, Any>"
+    when "NSError"                     then "Error?"
+    when "NSURL"                       then "URL"
+    when "NSData"                      then "Data"
+    when "NSNumber"                    then "NSNumber" # 特殊处理需要结合实际数值类型
+    when "NSDate"                      then "Date"
+    
+    # 基础数值类型
+    when "NSInteger"                   then "Int"
+    when "NSUInteger"                  then "UInt"
+    when "CGFloat"                     then "CGFloat"
+    when "CGPoint"                     then "CGPoint"
+    when "CGRect"                      then "CGRect"
+    when "CGSize"                      then "CGSize"
+    when "BOOL"                        then "Bool"
+    when "Boolean"                     then "Bool"
+    when "double"                      then "Double"
+    when "float"                       then "Float"
+    when "long"                        then "Int"
+    when "long long"                   then "Int64"
+
+
+    # 特殊类型
+    when "id"                          then "AnyObject"
+    when "Class"                       then "AnyClass"
+    when "SEL"                         then "Selector"
+    when "Protocol"                    then "Protocol"
+    when "instancetype"                then "Self"
+    when "void"                        then "Void"
+  
+    # # # 函数指针/Block 类型（需二次处理）
+    # when /void\s*\(\^\)/               then convert_block_to_closure(return_type)
+    # when /(.+?)\s*\(\^\)/              then convert_block_to_closure(return_type)
+    
+    # # 指针类型保留原始表示
+    # when /(.+?\s*\*+)/                 then return_type
+    
+    else
+      # # 处理Block类型
+      if clean_type.match(/^\s*(?:void|.+?)\s*\(\^\)/)
+        convert_block_to_closure(clean_type)
+      # 处理自定义的block
+      elsif clean_type =~ /(.*?[B|b]lock$)/
+        if is_nullable
+          "#{clean_type}?"
+        else
+          "@escaping #{clean_type}"
+        end
+      # 处理其他指针类型（去掉指针符号后返回基础类型名）
+      elsif clean_type.include?('*')
+        base_type
+      else
+        # 默认保留原类型
+        clean_type
+      end
+    end
+  end
+
+  #  # 测试用例
+  #  puts convert_block_to_closure('void (^)()')                # 输出: () -> Void
+  #  puts convert_block_to_closure('NSInteger (^)(BOOL)')       # 输出: (Bool) -> Int
+  #  puts convert_block_to_closure('NSString *(^)(NSInteger)')  # 输出: (Int) -> String?
+  #  puts convert_block_to_closure('void (^)(NSInteger, BOOL)') # 输出: (Int, Bool) -> Void
+  def self.convert_block_to_closure(block_signature)
+    # 正则表达式解释：
+    # ^([\w\s\*]+)\s*\(\^\)\s*(?:\((.*?)\))?\s*$
+    # 1. ([\w\s\*]+): 捕获返回值类型（如 void、NSInteger、NSString * 等）。
+    # 2. \(\^\): 匹配 '^' 表示这是一个 block。
+    # 3. (?:\((.*?)\))? : 可选地捕获参数列表（括号中的内容）。
+    if block_signature =~ /^([\w\s\*]+)\s*\(\^\)\s*(?:\((.*?)\))?\s*$/
+      return_type = $1.strip
+      params = $2 ? $2.split(',').map(&:strip) : []
+      
+      # 转换返回值类型
+      swift_return_type = convert_oc_type_to_swift(return_type)
+
+      # 转换参数类型
+      swift_params = params.map do |param|
+        param_parts = param.split(' ')
+        param_type =convert_oc_type_to_swift(param_parts.first)
+        "#{param_type}"
+      end.join(", ").gsub("Void","")
+
+      # 构造最终的 Swift 闭包类型
+      result = "@escaping (#{swift_params}) -> #{swift_return_type}"
+    else
+      raise ArgumentError, "Invalid block signature: #{block_signature}"
+    end
+  end
+
 end

data/lib/cocoapods-privacy/confuse/ObjCMethodAPIConverter.rb

@@ -3,7 +3,9 @@ module Confuse
   class ObjCMethodAPIConverter
       # Regular expression to match Objective-C method declarations
       # def initialize
-        @regex = /^[+-]\s*\(\s*([\w\s*]+)\s*\**\s*\)\s*(.+)/
+  
+        # @blockRegex = /#{ConfuseUtils.oc_block_regular}/
+        # @regex = /#{ConfuseUtils.noneBlock}/
         @param_regex = /(\w+):\s*\(([^:]+)\)(\w+)/x
       # end
     
@@ -16,102 +18,43 @@ module Confuse
         is_static = objc_method_declaration.start_with?("+")
         preFuncDes = is_static ? "static " : ""
     
-    
+        regular = ConfuseUtils.oc_func_regular(objc_method_declaration,true)
         # Match the method declaration using the regex
-        matches = objc_method_declaration.match(@regex)
+        matches = objc_method_declaration.match(regular)
         return nil,nil unless matches
 
         # Extract components from the matched regex groups
-        return_type = matches[1] || "Void"
-        param_section = matches[2] || ""
-        method_name = matches[2]
+        return_type = matches[2] || "Void"
+        method_name = matches[3]
+        param_section = (matches[3] + (matches[4] || "")) || ""
+        # puts "matches = #{matches}"
+        # puts "objc_method_declaration = #{objc_method_declaration}"
         # puts  "return_type = #{return_type}"
         # puts  "param_section = #{param_section}"
         # puts "method_name = #{method_name}"
 
+        is_nullable = return_type.include?("nullable")
+
         # Convert return type to Swift equivalent
         return_type = convert_oc_type_to_swift(return_type)
+        return_type.gsub!(Regexp.union('nullable', 'nonnull', 'null_unspecified', 'null_resettable'), '')
     
         # Extract parameters from the method declaration
         params = extract_parameters(param_section)
         method_name = extract_methodName(param_section,method_name)
-        # puts "params = #{params}"
     
         # Construct the Swift method declaration
         swift_method_declaration = "#{preFuncDes}public func #{method_name}(#{params.join(', ')})"
         swift_method_declaration += " -> #{return_type}" unless return_type == "Void"
         
-        return swift_method_declaration, extract_parameter_names(param_section)
+        return is_nullable, return_type, swift_method_declaration,  extract_parameter_names(param_section)
       end
     
       private
     
       # Convert the Objective-C return type to a Swift type
       def self.convert_oc_type_to_swift(return_type)
-        # 去除类型末尾的指针符号和周围空格，生成基础类型名
-        # base_type = return_type.gsub(/\s*\*+$/, '').strip
-        base_type = return_type.gsub(/(\w+)\s*\*+\z/, '\1').strip
-        # base_type = return_type
-        # puts  "base_type = #{return_type}"
-
-        case base_type
-        # Foundation 基础类型
-        when "NSString"                    then "String"
-        when "NSMutableString"             then "String" # Swift 中 String 是值类型
-        when "NSArray"                     then "Array<Any>"
-        when "NSMutableArray"              then "Array<Any>"
-        when "NSSet"                       then "Set<Any>"
-        when "NSMutableSet"                then "Set<Any>"
-        when "NSDictionary"                then "Dictionary<AnyHashable, Any>"
-        when "NSMutableDictionary"         then "Dictionary<AnyHashable, Any>"
-        when "NSError"                     then "Error?"
-        when "NSURL"                       then "URL"
-        when "NSData"                      then "Data"
-        when "NSNumber"                    then "NSNumber" # 特殊处理需要结合实际数值类型
-        when "NSDate"                      then "Date"
-        
-        # 基础数值类型
-        when "NSInteger"                   then "Int"
-        when "NSUInteger"                  then "UInt"
-        when "CGFloat"                     then "CGFloat"
-        when "CGPoint"                     then "CGPoint"
-        when "CGRect"                      then "CGRect"
-        when "CGSize"                      then "CGSize"
-        when "BOOL"                        then "Bool"
-        when "Boolean"                     then "Bool"
-        when "double"                      then "Double"
-        when "float"                       then "Float"
-        when "long"                        then "Int"
-        when "long long"                   then "Int64"
-
-
-        # 特殊类型
-        when "id"                          then "Any"
-        when "Class"                       then "AnyClass"
-        when "SEL"                         then "Selector"
-        when "Protocol"                    then "Protocol"
-        when "instancetype"                then "Self"
-        when "void"                        then "Void"
-      
-        # # # 函数指针/Block 类型（需二次处理）
-        # when /void\s*\(\^\)/               then convert_block_to_closure(return_type)
-        # when /(.+?)\s*\(\^\)/              then convert_block_to_closure(return_type)
-        
-        # # 指针类型保留原始表示
-        # when /(.+?\s*\*+)/                 then return_type
-        
-        else
-          # # 处理Block类型
-          if return_type.match(/^\s*(?:void|.+?)\s*\(\^\)/)
-            convert_block_to_closure(return_type)
-          # 处理其他指针类型（去掉指针符号后返回基础类型名）
-          elsif return_type.include?('*')
-            base_type
-          else
-            # 默认保留原类型
-            return_type
-          end
-        end
+        return ConfuseUtils.convert_oc_type_to_swift(return_type)
       end
     
       # Extract parameters from the parameter section
@@ -157,38 +100,7 @@ module Confuse
       end
     
       
-      #  # 测试用例
-      #  puts convert_block_to_closure('void (^)()')                # 输出: () -> Void
-      #  puts convert_block_to_closure('NSInteger (^)(BOOL)')       # 输出: (Bool) -> Int
-      #  puts convert_block_to_closure('NSString *(^)(NSInteger)')  # 输出: (Int) -> String?
-      #  puts convert_block_to_closure('void (^)(NSInteger, BOOL)') # 输出: (Int, Bool) -> Void
-      def self.convert_block_to_closure(block_signature)
-
-        # 正则表达式解释：
-        # ^([\w\s\*]+)\s*\(\^\)\s*(?:\((.*?)\))?\s*$
-        # 1. ([\w\s\*]+): 捕获返回值类型（如 void、NSInteger、NSString * 等）。
-        # 2. \(\^\): 匹配 '^' 表示这是一个 block。
-        # 3. (?:\((.*?)\))? : 可选地捕获参数列表（括号中的内容）。
-        if block_signature =~ /^([\w\s\*]+)\s*\(\^\)\s*(?:\((.*?)\))?\s*$/
-          return_type = $1.strip
-          params = $2 ? $2.split(',').map(&:strip) : []
-          
-          # 转换返回值类型
-          swift_return_type = convert_oc_type_to_swift(return_type)
-
-          # 转换参数类型
-          swift_params = params.map do |param|
-            param_parts = param.split(' ')
-            param_type =convert_oc_type_to_swift(param_parts.first)
-            "#{param_type}"
-          end.join(", ").gsub("Void","")
-
-          # 构造最终的 Swift 闭包类型
-          result = "@escaping (#{swift_params}) -> #{swift_return_type}"
-        else
-          raise ArgumentError, "Invalid block signature: #{block_signature}"
-        end
-      end
+     
   end
 end
   

data/lib/cocoapods-privacy/confuse/SwiftCallAssembly.rb

@@ -4,11 +4,12 @@ module Confuse
         #method_confuse 用来替换掉函数名 儒 BB_Confuse_asdasfas
         #swift 完整函数 如  @objc public func calculateAreaWithWidth(width: (Bool, String) -> Void, height: CGFloat) -> CGFloat
         #params 参数名数组 width, height
-        def self.assembly(method_confuse,swift_method_declaration,params)
-            is_return = true
+        def self.assembly(method_confuse,swift_method_declaration,params, is_nullable, return_type)
+            is_return = (return_type != "Void")
             is_static = swift_method_declaration.start_with?("static")
             caller = is_static ? "Self" : "self"
             returnFlag = is_return ? "return " : ""
+            optional = is_nullable ? "?" : ""
             
             params = params.map.with_index do |param, index|
                 if index == 0
@@ -17,7 +18,17 @@ module Confuse
                     "#{param}: #{param}"
                 end
             end
-            funcBody = "#{swift_method_declaration} {\n   #{returnFlag}#{caller}.#{method_confuse}(#{params.join(', ')})\n}"
+            funcBody = "#{swift_method_declaration}#{optional} {\n   #{returnFlag}#{caller}.#{method_confuse}(#{params.join(', ')})\n}"
+            return funcBody
+        end
+
+        #把oc属性组装成swift 计算属性
+        def self.assemblyProperty(property_origin, property_confuse, return_type, is_nullable)
+
+            final_return_type = (is_nullable ? "#{return_type}?" : return_type)
+
+            #如果是Any
+            funcBody = "public var #{property_origin} : #{final_return_type} {\n    get {\n        #{property_confuse}\n    }\n    set {\n        self.#{property_confuse} = newValue\n    }\n}\n"
             return funcBody
         end
     end

data/lib/cocoapods-privacy/confuse/confuse_installer_hook.rb

@@ -69,6 +69,11 @@ module Pod
             project = Xcodeproj::Project.open(File.basename(project_path))
             target = project.targets.first
             plist_path = target.resolved_build_setting('INFOPLIST_FILE', resolve_against: target).first.last
+
+            if project_path.nil? || plist_path.nil? || project_path.empty? || plist_path.empty?
+              return
+            end
+
             plist_path = File.join(File.dirname(project_path), plist_path)
             plist = Plist.parse_xml(plist_path)
             puts plist_path
@@ -76,6 +81,7 @@ module Pod
             unless plist.nil?
               is_confuse = plist['ISConfuse']
               if is_confuse.nil?
+                puts "None key for ISConfuse"
                 # 没有 --confuse 命令和 Info 配置, 不处理
               elsif is_confuse == true
                 enable_confuse()

data/lib/cocoapods-privacy/gem_version.rb

@@ -1,3 +1,3 @@
 module CocoapodsPrivacy
-  VERSION = "0.6.1"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-privacy
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - youhui
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-29 00:00:00.000000000 Z
+date: 2025-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler