cocoapods-binary-matchup 0.0.26 → 0.0.28

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

@@ -1,287 +0,0 @@
-require_relative 'helper/podfile_options'
-require_relative 'helper/feature_switches'
-require_relative 'helper/prebuild_sandbox'
-require_relative 'helper/passer'
-require_relative 'helper/target_checker'
-
-
-# NOTE:
-# This file will only be loaded on normal pod install step
-# so there's no need to check is_prebuild_stage
-
-
-
-# Provide a special "download" process for prebuilded pods.
-#
-# As the frameworks is already exsited in local folder. We
-# just create a symlink to the original target folder.
-#
-require_relative 'Integration_cache'
-
-module Pod
-    class Installer
-        class PodSourceInstaller
-
-            def install_for_prebuild!(standard_sanbox)
-                return if standard_sanbox.local? self.name
-                UI.puts "install_for_prebuild! start: #{self.name}"
-                
-                # 获取pod版本信息
-                prebuild_sandbox = Pod::PrebuildSandbox.from_standard_sandbox(standard_sanbox)
-
-                target_folder = standard_sanbox.pod_dir(self.name)
-                target_folder.rmtree if target_folder.exist?
-                
-                real_file_folder = prebuild_sandbox.framework_folder_path_for_pod_name(self.name)
-                
-                if real_file_folder.exist?
-                    # 拷贝到pods目录
-                    FileUtils.cp_r(real_file_folder, target_folder, :remove_destination => true)
-                    UI.puts "📦 Copied prebuilt files for #{self.name}: #{real_file_folder} -> #{target_folder}"
-                    
-                    # 3. 同时保存到缓存（如果缓存不存在）
-                    Pod::PrebuildCache::Cache.save_to_cache(self.name, target_folder.to_s)
-                else
-                    UI.puts "⚠️  Warning: Prebuilt files not found for #{self.name} at #{real_file_folder}"
-                    # 如果预构建文件不存在，创建空目录避免错误
-                    target_folder.mkpath
-                end
-            end
-
-        end
-    end
-end
-
-
-# Let cocoapods use the prebuild framework files in install process.
-#
-# the code only effect the second pod install process.
-#
-module Pod
-    class Installer
-
-
-        # Remove the old target files if prebuild frameworks changed
-        def remove_target_files_if_needed
-
-            changes = Pod::Prebuild::Passer.prebuild_pods_changes
-            updated_names = []
-            if changes == nil
-                updated_names = PrebuildSandbox.from_standard_sandbox(self.sandbox).exsited_framework_names
-            else
-                added = changes.added
-                changed = changes.changed 
-                deleted = changes.deleted 
-                updated_names = added + changed + deleted
-            end
-
-            updated_names.each do |name|
-                root_name = Specification.root_name(name)
-                next if self.sandbox.local?(root_name)
-                # 只有当不是预构建的pod时才删除，避免删除刚拷贝的预构建文件
-                next if self.prebuild_pod_names.include?(root_name)
-
-                # delete the cached files，include all cached files in the target
-                target_path = self.sandbox.pod_dir(root_name)
-                target_path.rmtree if target_path.exist?
-
-                support_path = sandbox.target_support_files_dir(root_name)
-                support_path.rmtree if support_path.exist?
-            end
-
-        end
-
-
-        # Modify specification to use only the prebuild framework after analyzing
-        old_method2 = instance_method(:resolve_dependencies)
-        define_method(:resolve_dependencies) do
-
-            # Remove the old target files, else it will not notice file changes
-            self.remove_target_files_if_needed
-
-            # call original
-            old_method2.bind(self).()
-
-            # check the pods
-            # Although we have did it in prebuild stage, it's not sufficient.
-            # Same pod may appear in another target in form of source code.
-            Prebuild.check_one_pod_should_have_only_one_target(self.prebuild_pod_targets)
-            UI.puts "🔍 prebuild_pod_names (cached): #{self.prebuild_pod_names}"
-            
-            # FIXED: 在主安装阶段强制重新计算 prebuild_pod_names
-            # 避免使用过期的缓存（可能在 aggregate_targets 初始化前被缓存为空）
-            fresh_prebuild_pod_names = self.refresh_prebuild_pod_names!
-            UI.puts "🔍 prebuild_pod_names (fresh): #{fresh_prebuild_pod_names}"
-
-            #
-            specs = self.analysis_result.specifications
-            # 只保留podspec中prebuild的pod，这里本质过滤了所有非prebuild的pod
-            prebuilt_specs = (specs.select do |spec|
-                self.prebuild_pod_names.include? spec.root.name
-            end)
-            
-            # make sturcture to fast get target by name
-            name_to_target_hash = self.pod_targets.reduce({}) do |sum, target|
-                sum[target.name] = target
-                sum
-            end
-
-            prebuilt_specs.each do |spec|
-                # `spec` may be a subspec, so we use the root's name 
-                root_name = spec.root.name
-                
-                target = name_to_target_hash[root_name]
-                # 如果是非源码编译成的pod（如本身是动态库和静态库依赖），则跳过集成，使用pod本身的配置
-                next if Prebuild::Passer.target_names_to_skip_integration_framework.include? target.pod_name
-
-                # use the prebuilt framework
-                original_vendored_frameworks = spec.attributes_hash["vendored_frameworks"] || []
-                if original_vendored_frameworks.kind_of?(String)
-                    original_vendored_frameworks = [original_vendored_frameworks]
-                end
-                framework_name = target.framework_name
-                if framework_name.kind_of?(Array)
-                    original_vendored_frameworks += framework_name
-                else
-                    # 始终使用Build目录下的路径，因为我们的install_for_prebuild!会复制framework到Build目录
-                    original_vendored_frameworks += [framework_name]
-                end
-                spec.attributes_hash["vendored_frameworks"] = original_vendored_frameworks
-                
-                # 对于静态库类型的pod，需要保留头文件，不能完全清空source_files
-                # 检查是否有vendored_libraries（静态库）
-                vendored_libraries = spec.attributes_hash["vendored_libraries"] || []
-                if vendored_libraries.kind_of?(String)
-                    vendored_libraries = [vendored_libraries]
-                end
-                
-                # 不管是静态库还是动态框架，都需要智能处理source_files
-                # 保留头文件和重要文件，清空.m/.swift等源码文件
-                current_source_files = spec.attributes_hash["source_files"] || []
-                if current_source_files.kind_of?(String)
-                    current_source_files = [current_source_files]
-                end
-                
-                if current_source_files.empty?
-                    # 如果原来就没有source_files，不做处理
-                    spec.attributes_hash["source_files"] = []
-                else
-                    # 智能处理source_files：保留头文件相关模式，清空源码文件模式
-                    header_files = current_source_files.select { |file_pattern| 
-                        pattern = file_pattern.to_s
-                        # 检查是否是头文件相关的模式，使用更精确的正则表达式
-                        pattern.match?(/\*+\.h$/) ||                    # 匹配 "*.h", "**/*.h" 等
-                        pattern.match?(/\*+\.hpp$/) ||                  # 匹配 "*.hpp", "**/*.hpp" 等  
-                        pattern.match?(/\*+\.hh$/) ||                   # 匹配 "*.hh", "**/*.hh" 等
-                        pattern.match?(/\*+\.modulemap$/) ||            # 匹配 "*.modulemap"
-                        pattern.match?(/\/\*\.h$/) ||                   # 匹配 "Sources/*.h" 等
-                        pattern.match?(/\/\*\.hpp$/) ||                 # 匹配 "Sources/*.hpp" 等
-                        pattern.match?(/\/\*\.hh$/) ||                  # 匹配 "Sources/*.hh" 等
-                        pattern.match?(/\/\*\.modulemap$/) ||           # 匹配 "Sources/*.modulemap"
-                        pattern.end_with?('.h', '.hpp', '.hh', '.modulemap') || # 直接的头文件路径
-                        pattern.match?(/\*\*?\/\*$/)                    # 通用通配符保留，如 "Sources/*", "**/*"
-                    }
-                    
-                    # 如果没有找到明确的头文件模式，保留原有的source_files
-                    # 这样可以避免意外删除重要的头文件
-                    if header_files.empty?
-                        spec.attributes_hash["source_files"] = current_source_files
-                    else
-                        UI.puts "📋 #{spec.root.name} header_files: #{header_files}"
-                        spec.attributes_hash["source_files"] = header_files
-                    end
-                end
-
-                # to remove the resurce bundle target. 
-                # When specify the "resource_bundles" in podspec, xcode will generate a bundle 
-                # target after pod install. But the bundle have already built when the prebuit
-                # phase and saved in the framework folder. We will treat it as a normal resource
-                # file.
-                # https://github.com/leavez/cocoapods-binary/issues/29
-                if spec.attributes_hash["resource_bundles"]
-                    bundle_names = spec.attributes_hash["resource_bundles"].keys
-                    spec.attributes_hash["resource_bundles"] = nil 
-                    current_resources = spec.attributes_hash["resources"] || []
-
-                    if current_resources.kind_of?(String)
-                        current_resources = [current_resources]
-                    end
-
-                    current_resources += bundle_names.map{|n| n+".bundle"}
-                    spec.attributes_hash["resources"] = current_resources
-                end
-
-                # to avoid the warning of missing license
-                spec.attributes_hash["license"] = {} 
-            end
-
-        end
-
-
-        # Override the download step to skip download and prepare file in target folder
-        old_method = instance_method(:install_source_of_pod)
-        define_method(:install_source_of_pod) do |pod_name|
-
-            # copy from original，创建一个单pod的安装器
-            pod_installer = create_pod_installer(pod_name)
-            # \copy from original
-            
-            if self.prebuild_pod_names.include? pod_name
-                UI.puts "📦 [#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}] Installing prebuild pod: #{pod_name}"
-                pod_installer.install_for_prebuild!(self.sandbox)
-                UI.puts "📦 [#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}] Installing prebuild pod: #{pod_name}"
-            else
-                UI.puts "📥 [#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}] Installing source pod: #{pod_name}"
-                pod_installer.install!
-                UI.puts "📥 [#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}] Installing source pod: #{pod_name}"
-            end
-
-            # copy from original
-            @installed_specs.concat(pod_installer.specs_by_platform.values.flatten.uniq)
-            # \copy from original
-        end
-
-
-    end
-end
-
-# A fix in embeded frameworks script.
-#
-# The framework file in pod target folder is a symblink. The EmbedFrameworksScript use `readlink`
-# to read the read path. As the symlink is a relative symlink, readlink cannot handle it well. So 
-# we override the `readlink` to a fixed version.
-#
-module Pod
-    module Generator
-        class EmbedFrameworksScript
-
-            old_method = instance_method(:script)
-            define_method(:script) do
-
-                script = old_method.bind(self).()
-                patch = <<-SH.strip_heredoc
-                    #!/bin/sh
-                
-                    # ---- this is added by cocoapods-binary ---
-                    # Readlink cannot handle relative symlink well, so we override it to a new one
-                    # If the path isn't an absolute path, we add a realtive prefix.
-                    old_read_link=`which readlink`
-                    readlink () {
-                        path=`$old_read_link $1`;
-                        if [ $(echo "$path" | cut -c 1-1) = '/' ]; then
-                            echo $path;
-                        else
-                            echo "`dirname $1`/$path";
-                        fi
-                    }
-                    # --- 
-                SH
-
-                # patch the rsync for copy dSYM symlink
-                script = script.gsub "rsync --delete", "rsync --copy-links --delete"
-                
-                patch + script
-            end
-        end
-    end
-end

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