cocoapods-binary-matchup 0.0.30 → 0.0.31

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

@@ -0,0 +1,320 @@
+require 'fileutils'
+require 'digest'
+require 'set'
+
+module Pod
+
+    class_attr_accessor :main_deployment_target_name
+
+    module PrebuildCache
+
+        class Cache
+            
+            # 类变量用于跟踪依赖关系和失效的pod
+            @@dependency_graph = {}
+            
+            # 获取缓存根目录
+            def self.cache_root_dir
+                cache_dir = File.expand_path("~/.PodCache/#{Pod.main_deployment_target_name}")
+                FileUtils.mkdir_p(cache_dir) unless Dir.exist?(cache_dir)
+                cache_dir
+            end
+            
+            # 获取manifest.lock缓存路径
+            def self.cached_manifest_path
+                File.join(cache_root_dir, 'Manifest.lock')
+            end
+            
+            # 获取特定pod的缓存目录
+            def self.cache_dir_for_pod(pod_name)
+                File.join(cache_root_dir, pod_name)
+            end
+            
+            # 获取pod的版本信息，优先使用commit hash
+            def self.get_pod_version(sandbox, pod_name)
+                UI.puts "🔍 starting get pod version: #{pod_name}"
+                UI.puts "🔍 get_pod_version sandbox: #{sandbox.manifest_path}"
+                checkout_options = sandbox.manifest.checkout_options_for_pod_named(pod_name)
+                # 优先使用checkout_options中的检出来源
+                if checkout_options
+                    UI.puts "🔍 get pod checkout version: #{pod_name}"
+                    if checkout_options[:tag]
+                        UI.puts "🔍 get pod checkout version tag: #{pod_name}# - #{checkout_options[:tag]}"
+                        return checkout_options[:tag]
+                    end
+                    if checkout_options[:branch]
+                        UI.puts "🔍 get pod checkout version branch: #{pod_name}# - #{checkout_options[:branch]}"
+                        return checkout_options[:branch]
+                    end
+                    if checkout_options[:commit]
+                        UI.puts "🔍 get pod checkout version commit: #{pod_name}# - #{checkout_options[:commit]}"
+                        return checkout_options[:commit]
+                    end
+                end
+
+                # 如果checkout_options中没有版本信息，则使用dependency中的版本信息
+                dependency = sandbox.manifest.dependencies.find { |d| d.name == pod_name }
+                if dependency
+                    UI.puts "🔍 get pod dependency version: #{pod_name}"
+                    external_source = dependency.external_source
+                    if external_source
+                        UI.puts "🔍 get pod dependency version podspec: #{external_source}"
+                        if external_source[:commit]
+                            UI.puts "🔍 get pod dependency version commit: #{pod_name}# - #{external_source[:commit]}"
+                            return external_source[:commit]
+                        end
+                        if external_source[:branch]
+                            UI.puts "🔍 get pod dependency version branch: #{pod_name}# - #{external_source[:branch]}"
+                            return external_source[:branch]
+                        end
+                    end
+                end
+
+                # 如果checkout_options和dependency中没有版本信息，则使用podspec中的version
+                UI.puts "🔍 get pod spec version: #{pod_name}"
+                version = sandbox.manifest.version(pod_name).version
+                if version
+                    UI.puts "🔍 get pod spec version: #{pod_name}# - #{version}"
+                    return version
+                end
+
+                # 如果以上都失败，则返回unknown，理论上只要是正常的podfile.lock或者manifest.lock，都不会走到这里
+                UI.puts "🔍 get pod version failed: #{pod_name}"
+                return "unknown"
+            end
+            
+            # 检查缓存是否存在
+            def self.cache_exists?(pod_name)
+                cache_dir = cache_dir_for_pod(pod_name)
+                Pod::UI.puts "🔍 cache_exists? #{cache_dir}"
+                Dir.exist?(cache_dir) && !Dir.empty?(cache_dir)
+            end
+            
+            # 保存到缓存（如果缓存不存在的话）
+            def self.save_to_cache(pod_name, source_dir)
+                return unless Dir.exist?(source_dir)
+                
+                # 检查缓存是否已经存在，如果存在则不覆盖
+                if cache_exists?(pod_name)
+                    Pod::UI.puts "📦 Cache already exists for #{pod_name}, skipping save"
+                    return true
+                end
+                
+                cache_dir = cache_dir_for_pod(pod_name)
+                
+                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)
+                    return true
+                rescue => e
+                    Pod::UI.puts "❌ Failed to save #{pod_name} to cache: #{e.message}"
+                    return false
+                end
+            end
+            
+            # 保存当前manifest.lock到缓存目录
+            def self.save_manifest_to_cache(sandbox)
+                begin
+                    # 查找_Prebuild目录中的manifest.lock
+                    prebuild_manifest = sandbox.root + 'Manifest.lock'
+                    # 如果存在，复制到缓存目录
+                    if prebuild_manifest.exist?
+                        cached_path = cached_manifest_path
+                        FileUtils.cp(prebuild_manifest, cached_path)
+                        Pod::UI.puts "💾 save_manifest_to_cache Manifest.lock to cache: #{cached_path}"
+                        return true
+                    else
+                        Pod::UI.puts "⚠️ save_manifest_to_cache Manifest.lock not found in _Prebuild directory"
+                        return false
+                    end
+                rescue => e
+                    Pod::UI.puts "❌ save_manifest_to_cache save Manifest.lock to cache failed: #{e.message}"
+                    return false
+                end
+            end
+            
+            # 清空所有缓存
+            def self.clear_all_caches
+                begin
+                    cache_dir = cache_root_dir
+                    
+                    # 删除除了cached_manifest.lock之外的所有缓存
+                    Dir.glob("#{cache_dir}/*").each do |path|
+                        next if File.basename(path) == 'Manifest.lock'
+                        
+                        if Dir.exist?(path)
+                            FileUtils.rm_rf(path)
+                            Pod::UI.puts "🗑️  Cleared cache directory: #{File.basename(path)}"
+                        end
+                    end
+                    
+                    Pod::UI.puts "✅ All pod caches cleared due to dependency changes"
+                    
+                rescue => e
+                    Pod::UI.puts "❌ Error clearing caches: #{e.message}"
+                end
+            end
+            
+            # 验证pod版本一致性（与缓存时的manifest对比）
+            def self.validate_pod_version_consistency(pod_name, current_version)
+                begin
+                    manifest_path = cached_manifest_path
+                    Pod::UI.puts "🔍 validate_pod_version_consistency pod_name: #{pod_name} manifest_path: #{manifest_path}"
+                    # 如果没有缓存的manifest，认为一致（首次构建）
+                    unless File.exist?(manifest_path)
+                        return true
+                    end
+                    
+                    # 创建基于缓存manifest的临时sandbox来获取缓存版本
+                    cached_version = get_cached_pod_version(pod_name, cached_manifest_path)
+                    
+                    # 对比版本
+                    if current_version == cached_version
+                        return true
+                    else
+                        Pod::UI.puts "🔄 #{pod_name} version changed: #{cached_version} → #{current_version}"
+                        return false
+                    end
+                    
+                rescue => e
+                    Pod::UI.puts "⚠️  Error validating version consistency for #{pod_name}: #{e.message}"
+                    return false
+                end
+            end
+            
+            # 从缓存的manifest中获取pod版本（复用get_pod_version的逻辑）
+            def self.get_cached_pod_version(pod_name, cached_manifest_path)
+                begin
+                    # 使用缓存目录作为根目录创建PrebuildSandbox
+                    # 因为Manifest.lock就在cache_root_dir下，可以直接使用
+                    cache_dir = File.dirname(cached_manifest_path)
+                    temp_sandbox = Pod::PrebuildSandbox.new(cache_dir)
+                    
+                    # 复用现有的get_pod_version逻辑
+                    return get_pod_version(temp_sandbox, pod_name)
+                    
+                rescue => e
+                    Pod::UI.puts "⚠️  Error reading cached version for #{pod_name}: #{e.message}"
+                    return "unknown"
+                end
+            end
+            
+            # 获取指定target的反向依赖（哪些targets依赖于它）
+            def self.find_reverse_dependencies(target_to_find, all_pod_targets)
+                reverse_deps = all_pod_targets.select do |pod_target|
+                    # 跳过自己
+                    next false if pod_target.pod_name == target_to_find.pod_name
+                    # 检查当前pod_target的正向递归依赖中是否包含目标target
+                    pod_target.recursive_dependent_targets.include?(target_to_find)
+                end
+
+                reverse_deps.map { |item| item.pod_name }
+            end
+
+            # 构建简单的依赖关系图（从targets获取）
+            def self.build_simple_dependency_graph(target, total_targets)                
+                return if total_targets.nil? || total_targets.empty?
+                
+                Pod::UI.puts "🔍 Building reverse dependency graph for cache validation..."
+                begin
+                    pod_name = target.pod_name
+                    @@dependency_graph[pod_name] = []
+                    dependencies = []
+                    temp_dependencies = find_reverse_dependencies(target, total_targets)
+                    if !temp_dependencies.nil?
+                        dependencies = temp_dependencies
+                    end
+
+                    @@dependency_graph[pod_name] = dependencies                    
+                rescue => e
+                    Pod::UI.puts "⚠️  Warning: Error processing target #{target}: #{e.message}"
+                end                
+            end
+            
+            # 删除pod的缓存
+            def self.invalidate_pod_cache(pod_name)
+                cache_dir = cache_dir_for_pod(pod_name)
+                Pod::UI.puts "🗑️ start Removed invalid cache for #{pod_name}"
+                if Dir.exist?(cache_dir)
+                    FileUtils.rm_rf(cache_dir)
+                    Pod::UI.puts "🗑️ end  Removed invalid cache for #{pod_name}"
+                end
+            end
+
+            def self.remove_all_invalid_cache(sandbox, all_targets)
+                all_targets.each do |target|
+                    build_simple_dependency_graph(target, all_targets)
+                    current_version = get_pod_version(sandbox, target.pod_name)
+                    if validate_pod_version_consistency(target.pod_name, current_version)
+                        Pod::UI.puts "🔍 validate_pod_version_consistency #{target.pod_name} #{current_version}"
+                    else
+                        cascade_invalidate_dependents(target.pod_name)
+                        Pod::UI.puts "❌ validate_pod_version_consistency #{target.pod_name} #{current_version}"
+                    end
+                end
+                Pod::UI.puts "📊 Dependency graph: #{@@dependency_graph}"
+            end
+            
+            # 级联失效依赖当前pod的其他pod
+            def self.cascade_invalidate_dependents(invalidated_pod)                
+                # 查找所有依赖invalidated_pod的pod
+                invalidate_pod_cache(invalidated_pod)
+                dependenciess = @@dependency_graph[invalidated_pod]
+                return if dependenciess.nil? || !dependenciess.any?
+                dependenciess.each do |dependent_pod|
+                    invalidate_pod_cache(dependent_pod)
+                end
+            end
+            
+            # 重置依赖验证状态并检查manifest一致性
+            def self.reset_dependency_validation(sandbox = nil)
+                @@dependency_graph.clear
+                Pod::UI.puts "🔄 Reset dependency validation state"
+            end
+            
+            # 从 ~/.PodCache 恢复缓存到 _prebuild 目录（版本感知版）
+            def self.restore_from_pod_cache(pod_name, prebuild_sandbox)
+                begin
+                    Pod::UI.puts "🔍 Checking cache for #{pod_name}"
+                    
+                    # 获取pod版本信息
+                    pod_version = get_pod_version(prebuild_sandbox, pod_name)
+                    
+                    # 检查缓存是否存在
+                    unless cache_exists?(pod_name)
+                        Pod::UI.puts "⚠️  No cache found for #{pod_name}"
+                        return false
+                    end
+                    
+                    # 所有验证通过，从缓存恢复
+                    cache_dir = cache_dir_for_pod(pod_name)
+                    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 "📦 Successfully restored #{pod_name} (#{pod_version}) from cache"
+                    return true
+                    
+                rescue => e
+                    Pod::UI.puts "❌ Error restoring from cache: #{e.message}"
+                    # 出错时也标记为失效
+                    return false
+                end
+            end
+        end
+    end
+end