cocoapods-binary-matchup 0.0.2 → 0.0.4

data/lib/cocoapods-binary-matchup/Integration_cache.rb

@@ -0,0 +1,422 @@
+require 'fileutils'
+require 'digest'
+
+module Pod
+    module PrebuildCache
+        class Cache
+            
+            # 获取缓存根目录
+            def self.cache_root_dir
+                cache_dir = File.expand_path("~/.PodCache")
+                FileUtils.mkdir_p(cache_dir) unless Dir.exist?(cache_dir)
+                cache_dir
+            end
+            
+            # 获取特定pod的缓存目录
+            def self.cache_dir_for_pod(pod_name, version)
+                File.join(cache_root_dir, pod_name, version)
+            end
+            
+            # 获取pod的版本信息，优先使用commit hash
+            def self.get_pod_version(sandbox, pod_name)
+                begin
+                    Pod::UI.puts "🔍 Looking for version of: #{pod_name}"
+                    # 优先级：commit > tag > version > timestamp
+                    
+                    # 1. 首先尝试从Manifest.lock获取commit信息
+                    manifest_lock = sandbox.root + 'Manifest.lock'
+                    if manifest_lock.exist?
+                        manifest_content = YAML.load_file(manifest_lock)
+                        
+                        # 优先检查 CHECKOUT OPTIONS 中的commit信息
+                        checkout_options = manifest_content['CHECKOUT OPTIONS'] || {}
+                        if checkout_options[pod_name].is_a?(Hash)
+                            checkout_info = checkout_options[pod_name]
+                            # 优先使用commit，然后是tag
+                            if checkout_info[:commit] || checkout_info['commit']
+                                commit = checkout_info[:commit] || checkout_info['commit']
+                                Pod::UI.puts "📋 Using commit for #{pod_name}: #{commit[0..7]}..."
+                                return commit
+                            elsif checkout_info[:tag] || checkout_info['tag']
+                                tag = checkout_info[:tag] || checkout_info['tag']
+                                Pod::UI.puts "📋 Using tag for #{pod_name}: #{tag}"
+                                return tag
+                            end
+                        end
+                        
+                        # 如果没有commit信息，查找版本信息
+                        pods = manifest_content['PODS'] || []
+                        Pod::UI.puts "🔍 Searching in #{pods.length} pod entries from Manifest.lock"
+                        
+                        pods.each do |pod_entry|
+                            if pod_entry.is_a?(Hash)
+                                # Hash 格式：{"PodName (1.0.0)" => [...]}
+                                pod_entry.each do |key, _|
+                                    key_str = key.to_s
+                                    
+                                    # 使用更灵活的匹配逻辑，支持subspec
+                                    match = key_str.match(/^#{Regexp.escape(pod_name)}\s*\(([^)]+)\)/)
+                                    if match
+                                        Pod::UI.puts "📋 Found exact match! Using version for #{pod_name}: #{match[1]}"
+                                        return match[1]
+                                    end
+                                    
+                                    # 如果精确匹配失败，尝试检查是否是subspec的情况
+                                    # 例如：pod_name是"GoogleUtilities/AppDelegateSwizzler"，但key是"GoogleUtilities/AppDelegateSwizzler (8.1.0)"
+                                    if key_str.include?(pod_name) && key_str.include?('(')
+                                        version_match = key_str.match(/\(([^)]+)\)/)
+                                        if version_match
+                                            Pod::UI.puts "📋 Found partial match! Using version for #{pod_name}: #{version_match[1]}"
+                                            return version_match[1]
+                                        end
+                                    end
+                                end
+                            elsif pod_entry.is_a?(String)
+                                # String 格式："PodName (1.0.0)"
+                                
+                                match = pod_entry.match(/^#{Regexp.escape(pod_name)}\s*\(([^)]+)\)/)
+                                if match
+                                    Pod::UI.puts "📋 Found exact match! Using version for #{pod_name}: #{match[1]}"
+                                    return match[1]
+                                end
+                                
+                                # 如果精确匹配失败，尝试部分匹配
+                                if pod_entry.include?(pod_name) && pod_entry.include?('(')
+                                    version_match = pod_entry.match(/\(([^)]+)\)/)
+                                    if version_match
+                                        Pod::UI.puts "📋 Found partial match! Using version for #{pod_name}: #{version_match[1]}"
+                                        return version_match[1]
+                                    end
+                                end
+                            end
+                        end
+                        
+                        Pod::UI.puts "⚠️  No version found for #{pod_name} in Manifest.lock"
+                    end
+
+                    
+                    
+                    # 2. 如果Manifest.lock不存在或没找到，尝试从Podfile.lock获取
+                    podfile_lock = sandbox.root.parent + 'Podfile.lock'
+                    if podfile_lock.exist?
+                        podfile_content = YAML.load_file(podfile_lock)
+                        
+                        # 同样优先检查checkout信息
+                        checkout_options = podfile_content['CHECKOUT OPTIONS'] || {}
+                        if checkout_options[pod_name].is_a?(Hash)
+                            checkout_info = checkout_options[pod_name]
+                            if checkout_info[:commit] || checkout_info['commit']
+                                commit = checkout_info[:commit] || checkout_info['commit']
+                                Pod::UI.puts "📋 Using commit for #{pod_name}: #{commit[0..7]}..."
+                                return commit
+                            elsif checkout_info[:tag] || checkout_info['tag']
+                                tag = checkout_info[:tag] || checkout_info['tag']
+                                Pod::UI.puts "📋 Using tag for #{pod_name}: #{tag}"
+                                return tag
+                            end
+                        end
+                        
+                        # 查找版本信息
+                        pods = podfile_content['PODS'] || []
+                        Pod::UI.puts "🔍 Searching in #{pods.length} pod entries from Podfile.lock"
+                        
+                        pods.each do |pod_entry|
+                            if pod_entry.is_a?(Hash)
+                                pod_entry.each do |key, _|
+                                    key_str = key.to_s
+                                    
+                                    # 使用更灵活的匹配逻辑，支持subspec
+                                    match = key_str.match(/^#{Regexp.escape(pod_name)}\s*\(([^)]+)\)/)
+                                    if match
+                                        Pod::UI.puts "📋 Found exact match! Using version for #{pod_name}: #{match[1]}"
+                                        return match[1]
+                                    end
+                                    
+                                    # 如果精确匹配失败，尝试部分匹配
+                                    if key_str.include?(pod_name) && key_str.include?('(')
+                                        version_match = key_str.match(/\(([^)]+)\)/)
+                                        if version_match
+                                            Pod::UI.puts "📋 Found partial match! Using version for #{pod_name}: #{version_match[1]}"
+                                            return version_match[1]
+                                        end
+                                    end
+                                end
+                            elsif pod_entry.is_a?(String)
+                                # String 格式："PodName (1.0.0)"
+                                
+                                match = pod_entry.match(/^#{Regexp.escape(pod_name)}\s*\(([^)]+)\)/)
+                                if match
+                                    Pod::UI.puts "📋 Found exact match! Using version for #{pod_name}: #{match[1]}"
+                                    return match[1]
+                                end
+                                
+                                # 如果精确匹配失败，尝试部分匹配
+                                if pod_entry.include?(pod_name) && pod_entry.include?('(')
+                                    version_match = pod_entry.match(/\(([^)]+)\)/)
+                                    if version_match
+                                        Pod::UI.puts "📋 Found partial match! Using version for #{pod_name}: #{version_match[1]}"
+                                        return version_match[1]
+                                    end
+                                end
+                            end
+                        end
+                        
+                        Pod::UI.puts "⚠️  No version found for #{pod_name} in Podfile.lock"
+                    end
+                    
+                    # 3. 如果无法从任何lockfile获取，使用时间戳作为版本
+                    timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+                    Pod::UI.puts "⚠️  Warning: Cannot find version/commit for #{pod_name} in lock files, using timestamp: #{timestamp}"
+                    return timestamp
+                rescue => e
+                    timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+                    Pod::UI.puts "⚠️  Warning: Error getting version for #{pod_name}: #{e.message}, using timestamp: #{timestamp}"
+                    return timestamp
+                end
+            end
+            
+            # 计算目录内容的哈希值（用于验证缓存完整性）
+            def self.calculate_dir_hash(dir_path)
+                return nil unless Dir.exist?(dir_path)
+                
+                files = Dir.glob("#{dir_path}/**/*", File::FNM_DOTMATCH).select { |f| File.file?(f) }
+                files.sort!
+                
+                hasher = Digest::SHA256.new
+                files.each do |file|
+                    # 添加文件路径和修改时间到哈希计算中
+                    relative_path = file.sub("#{dir_path}/", "")
+                    hasher.update(relative_path)
+                    hasher.update(File.mtime(file).to_s)
+                end
+                
+                hasher.hexdigest
+            end
+            
+            # 检查缓存是否存在
+            def self.cache_exists?(pod_name, version)
+                cache_dir = cache_dir_for_pod(pod_name, version)
+                Dir.exist?(cache_dir) && !Dir.empty?(cache_dir)
+            end
+            
+            # 检查缓存是否存在且有效（用于验证完整性）
+            def self.cache_valid?(pod_name, version, source_dir = nil)
+                cache_dir = cache_dir_for_pod(pod_name, version)
+                return false unless Dir.exist?(cache_dir)
+                
+                # 如果没有提供源目录，只检查缓存是否存在
+                return true if source_dir.nil?
+                
+                # 检查缓存的哈希文件
+                hash_file = File.join(cache_dir, '.cache_hash')
+                return false unless File.exist?(hash_file)
+                
+                begin
+                    cached_hash = File.read(hash_file).strip
+                    current_hash = calculate_dir_hash(source_dir)
+                    
+                    return cached_hash == current_hash
+                rescue => e
+                    Pod::UI.puts "⚠️  Warning: Cannot validate cache for #{pod_name}: #{e.message}"
+                    return false
+                end
+            end
+            
+            # 从缓存恢复pod
+            def self.restore_from_cache(pod_name, version, target_dir)
+                cache_dir = cache_dir_for_pod(pod_name, version)
+                
+                return false unless Dir.exist?(cache_dir)
+                
+                begin
+                    # 删除目标目录
+                    FileUtils.rm_rf(target_dir) if Dir.exist?(target_dir)
+                    
+                    # 从缓存拷贝到目标目录
+                    FileUtils.cp_r(cache_dir, target_dir, :remove_destination => true)
+                    
+                    # 删除缓存标记文件
+                    hash_file = File.join(target_dir, '.cache_hash')
+                    File.delete(hash_file) if File.exist?(hash_file)
+                    
+                    Pod::UI.puts "📦 Restored #{pod_name} (#{version}) from cache"
+                    return true
+                rescue => e
+                    Pod::UI.puts "❌ Failed to restore #{pod_name} from cache: #{e.message}"
+                    return false
+                end
+            end
+            
+            # 保存到缓存（如果缓存不存在的话）
+            def self.save_to_cache(pod_name, version, source_dir)
+                return unless Dir.exist?(source_dir)
+                
+                # 检查缓存是否已经存在，如果存在则不覆盖
+                if cache_exists?(pod_name, version)
+                    Pod::UI.puts "📦 Cache already exists for #{pod_name} (#{version}), skipping save"
+                    return true
+                end
+                
+                cache_dir = cache_dir_for_pod(pod_name, version)
+                
+                begin
+                    # 创建缓存目录
+                    FileUtils.mkdir_p(File.dirname(cache_dir))
+                    
+                    # 删除旧缓存（如果存在）
+                    FileUtils.rm_rf(cache_dir) if Dir.exist?(cache_dir)
+                    
+                    # 拷贝到缓存
+                    FileUtils.cp_r(source_dir, cache_dir, :remove_destination => true)
+                    
+                    # 保存哈希值
+                    source_hash = calculate_dir_hash(source_dir)
+                    hash_file = File.join(cache_dir, '.cache_hash')
+                    File.write(hash_file, source_hash)
+                    
+                    Pod::UI.puts "💾 Saved #{pod_name} (#{version}) to cache"
+                    return true
+                rescue => e
+                    Pod::UI.puts "❌ Failed to save #{pod_name} to cache: #{e.message}"
+                    return false
+                end
+            end
+            
+            # 尝试从缓存拷贝到目标目录（如果缓存存在）
+            def self.copy_from_cache_if_exists(pod_name, version, target_dir)
+                return false unless cache_exists?(pod_name, version)
+                
+                cache_dir = cache_dir_for_pod(pod_name, version)
+                
+                begin
+                    # 删除目标目录
+                    FileUtils.rm_rf(target_dir) if Dir.exist?(target_dir)
+                    
+                    # 从缓存拷贝到目标目录
+                    FileUtils.cp_r(cache_dir, target_dir, :remove_destination => true)
+                    
+                    # 删除缓存标记文件
+                    hash_file = File.join(target_dir, '.cache_hash')
+                    File.delete(hash_file) if File.exist?(hash_file)
+                    
+                    Pod::UI.puts "📦 Copied #{pod_name} (#{version}) from cache"
+                    return true
+                rescue => e
+                    Pod::UI.puts "❌ Failed to copy #{pod_name} from cache: #{e.message}"
+                    return false
+                end
+            end
+            
+            # 清理过期缓存（可选功能）
+            def self.clean_expired_cache(days = 30)
+                return unless Dir.exist?(cache_root_dir)
+                
+                cutoff_time = Time.now - (days * 24 * 60 * 60)
+                cleaned_count = 0
+                
+                Dir.glob("#{cache_root_dir}/*/*").each do |cache_dir|
+                    next unless Dir.exist?(cache_dir)
+                    
+                    if File.mtime(cache_dir) < cutoff_time
+                        begin
+                            FileUtils.rm_rf(cache_dir)
+                            cleaned_count += 1
+                            Pod::UI.puts "🗑️  Cleaned expired cache: #{File.basename(File.dirname(cache_dir))}/#{File.basename(cache_dir)}"
+                        rescue => e
+                            Pod::UI.puts "❌ Failed to clean cache #{cache_dir}: #{e.message}"
+                        end
+                    end
+                end
+                
+                Pod::UI.puts "✅ Cleaned #{cleaned_count} expired cache entries" if cleaned_count > 0
+            end
+            
+            # 获取缓存统计信息
+            def self.cache_stats
+                return {} unless Dir.exist?(cache_root_dir)
+                
+                stats = {
+                    total_pods: 0,
+                    total_versions: 0,
+                    total_size: 0
+                }
+                
+                Dir.glob("#{cache_root_dir}/*").each do |pod_dir|
+                    next unless Dir.exist?(pod_dir)
+                    
+                    stats[:total_pods] += 1
+                    
+                    Dir.glob("#{pod_dir}/*").each do |version_dir|
+                        next unless Dir.exist?(version_dir)
+                        
+                        stats[:total_versions] += 1
+                        
+                        # 计算目录大小
+                        size = `du -sk "#{version_dir}" 2>/dev/null`.split.first.to_i * 1024
+                        stats[:total_size] += size
+                    end
+                end
+                
+                stats
+            end
+            
+            # 打印缓存统计信息
+            def self.print_cache_stats
+                stats = cache_stats
+                if stats[:total_pods] > 0
+                    size_mb = (stats[:total_size] / 1024.0 / 1024.0).round(2)
+                    Pod::UI.puts "📊 Cache Stats: #{stats[:total_pods]} pods, #{stats[:total_versions]} versions, #{size_mb} MB"
+                else
+                    Pod::UI.puts "📊 Cache is empty"
+                end
+            end
+            
+            # 从 ~/.PodCache 恢复缓存到 _prebuild 目录
+            def self.restore_from_pod_cache(pod_name, prebuild_sandbox)
+                begin
+                    Pod::UI.puts "🔍 Checking cache for #{pod_name} #{prebuild_sandbox}"
+                    
+                    restored_count = 0
+                    missing_pods = []
+                    
+                    # 获取pod版本信息
+                    pod_version = get_pod_version(prebuild_sandbox, pod_name)
+                    
+                    # 检查缓存是否存在
+                    if cache_exists?(pod_name, pod_version)
+                        # 从缓存复制到_prebuild目录
+                        cache_dir = cache_dir_for_pod(pod_name, pod_version)
+                        target_dir = prebuild_sandbox.framework_folder_path_for_pod_name(pod_name)
+                        
+                        # 确保目标目录存在
+                        target_dir.parent.mkpath unless target_dir.parent.exist?
+                        
+                        # 复制缓存到_prebuild
+                        FileUtils.cp_r(cache_dir, target_dir, :remove_destination => true)
+                        
+                        # 删除缓存标记文件
+                        hash_file = target_dir + '.cache_hash'
+                        hash_file.delete if hash_file.exist?
+                        
+                        Pod::UI.puts "📦 Restored #{pod_name} (#{pod_version}) from cache"
+                        restored_count += 1
+                    else
+                        missing_pods << pod_name
+                    end
+                    
+                    if missing_pods.empty?
+                        Pod::UI.puts "✅ Successfully restored all #{restored_count} pods from cache"
+                        return true
+                    else
+                        Pod::UI.puts "⚠️  Missing cache for #{missing_pods.count} pods: #{missing_pods.join(', ')}"
+                        return false
+                    end
+                    
+                rescue => e
+                    Pod::UI.puts "❌ Error restoring from cache: #{e.message}"
+                    return false
+                end
+            end
+        end
+    end
+end

data/lib/cocoapods-binary-matchup/Main.rb

@@ -0,0 +1,171 @@
+# encoding: UTF-8
+require_relative 'helper/podfile_options'
+require_relative 'tool/tool'
+require_relative 'Integration_cache'
+
+module Pod    
+    class Podfile
+        module DSL
+            
+            # Enable prebuiding for all pods
+            # it has a lower priority to other binary settings
+            def all_binary!
+                DSL.prebuild_all = true
+            end
+
+            def simulator_build_disable!
+                DSL.simulator_build_enabled = false
+            end
+
+            # Enable bitcode for prebuilt frameworks
+            def enable_bitcode_for_prebuilt_frameworks!
+                DSL.bitcode_enabled = true
+            end
+
+            # Don't remove source code of prebuilt pods
+            # It may speed up the pod install if git didn't 
+            # include the `Pods` folder
+            def keep_source_code_for_prebuilt_frameworks!
+                DSL.dont_remove_source_code = true
+            end
+
+            # Add custom xcodebuild option to the prebuilding action
+            #
+            # You may use this for your special demands. For example: the default archs in dSYMs 
+            # of prebuilt frameworks is 'arm64 armv7 x86_64', and no 'i386' for 32bit simulator.
+            # It may generate a warning when building for a 32bit simulator. You may add following
+            # to your podfile
+            # 
+            #  ` set_custom_xcodebuild_options_for_prebuilt_frameworks :simulator => "ARCHS=$(ARCHS_STANDARD)" `
+            #
+            # Another example to disable the generating of dSYM file:
+            #
+            #  ` set_custom_xcodebuild_options_for_prebuilt_frameworks "DEBUG_INFORMATION_FORMAT=dwarf"`
+            # 
+            #
+            # @param [String or Hash] options
+            #
+            #   If is a String, it will apply for device and simulator. Use it just like in the commandline.
+            #   If is a Hash, it should be like this: { :device => "XXXXX", :simulator => "XXXXX" }
+            #
+            def set_custom_xcodebuild_options_for_prebuilt_frameworks(options)
+                if options.kind_of? Hash
+                    DSL.custom_build_options = [ options[:device] ] unless options[:device].nil?
+                    DSL.custom_build_options_simulator = [ options[:simulator] ] unless options[:simulator].nil?
+                elsif options.kind_of? String
+                    DSL.custom_build_options = [options]
+                    DSL.custom_build_options_simulator = [options]
+                else
+                    raise "Wrong type."
+                end
+            end
+
+            class_attr_accessor :simulator_build_enabled
+            simulator_build_enabled = true
+
+            private
+            class_attr_accessor :prebuild_all
+            prebuild_all = false
+
+            class_attr_accessor :bitcode_enabled
+            bitcode_enabled = false
+
+            class_attr_accessor :dont_remove_source_code
+            dont_remove_source_code = false
+
+            class_attr_accessor :custom_build_options
+            class_attr_accessor :custom_build_options_simulator
+            self.custom_build_options = []
+            self.custom_build_options_simulator = []
+        end
+    end
+end
+
+Pod::HooksManager.register('cocoapods-binary-matchup', :pre_install) do |installer_context|
+
+    require_relative 'helper/feature_switches'
+    if Pod.is_prebuild_stage
+        next
+    end
+    
+    # [Check Environment]
+    # check user_framework is on
+    podfile = installer_context.podfile
+    podfile.target_definition_list.each do |target_definition|
+        next if target_definition.prebuild_framework_names.empty?
+        if not target_definition.uses_frameworks?
+            STDERR.puts "[!] Cocoapods-binary requires `use_frameworks!`".red
+            exit
+        end
+    end
+    
+    
+    # -- step 1: prebuild framework ---
+    # Execute a sperated pod install, to generate targets for building framework,
+    # then compile them to framework files.
+    require_relative 'helper/prebuild_sandbox'
+    require_relative 'Prebuild'
+    
+    Pod::UI.puts "🚀  Prebuild frameworks"
+    
+    # Fetch original installer (which is running this pre-install hook) options,
+    # then pass them to our installer to perform update if needed
+    # Looks like this is the most appropriate way to figure out that something should be updated
+    
+    update = nil
+    repo_update = nil
+    
+    include ObjectSpace
+    ObjectSpace.each_object(Pod::Installer) { |installer|
+        update = installer.update
+        repo_update = installer.repo_update
+    }
+    
+    # control features
+    Pod.is_prebuild_stage = true
+    Pod::Podfile::DSL.enable_prebuild_patch true  # enable sikpping for prebuild targets
+    Pod::Installer.force_disable_integration true # don't integrate targets
+    Pod::Config.force_disable_write_lockfile true # disbale write lock file for perbuild podfile
+    Pod::Installer.disable_install_complete_message true # disable install complete message
+    
+    # make another custom sandbox
+    standard_sandbox = installer_context.sandbox
+    prebuild_sandbox = Pod::PrebuildSandbox.from_standard_sandbox(standard_sandbox)
+    
+    # get the podfile for prebuild
+    prebuild_podfile = Pod::Podfile.from_ruby(podfile.defined_in_file)
+    
+    # install
+    lockfile = installer_context.lockfile
+    binary_installer = Pod::Installer.new(prebuild_sandbox, prebuild_podfile, lockfile)
+    
+    # 优化的三级缓存逻辑
+    if binary_installer.have_exact_prebuild_cache? && !update
+        # 1. 优先：_prebuild 目录已有完整缓存
+        Pod::UI.puts "📦 Using exact prebuild cache from _Prebuild"
+        binary_installer.install_when_cache_hit!
+    else
+        # 3. 最后：重新构建
+        Pod::UI.puts "🔨 Building frameworks (no cache available)"
+        binary_installer.update = update
+        binary_installer.repo_update = repo_update
+        binary_installer.install!
+    end
+    
+    
+    # reset the environment
+    Pod.is_prebuild_stage = false
+    Pod::Installer.force_disable_integration false
+    Pod::Podfile::DSL.enable_prebuild_patch false
+    Pod::Config.force_disable_write_lockfile false
+    Pod::Installer.disable_install_complete_message false
+    
+    
+    # -- step 2: pod install ---
+    # install
+    Pod::UI.puts "\n"
+    Pod::UI.puts "🤖  Pod Install"
+    require_relative 'Integration'
+    # go on the normal install step ...
+end
+