cocoapods-binary-matchup 0.0.29 → 0.0.30

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

@@ -1,320 +0,0 @@
-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