cocoapods-sled 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 43c917cafb47d678f2239fb021da3f310553b050109042099e7880a7198789d4
+  data.tar.gz: 0d4666749551dd568db76273d1d917527c39fcbbc245578cc42809a7713c1e21
+SHA512:
+  metadata.gz: 456e1bb2892aae9419d9221a85aab332df74c79966bdfd959a03486f3d6ddc2c1e9cce45eb92333e7f2b2b78e568626fbb805f827d5770976f77d93de414e6b6
+  data.tar.gz: bb1213c0390b8b7f04195821b3f96b5ee32f3afe6aaaf654a8948824e3234588dcb4337a7abf5fb9884271f417d26e2050cd557a84839070be741b944b5ddebf

data/lib/cocoapods/sled/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Cocoapods
+  module Sled
+    VERSION = "0.1.0"
+  end
+end

data/lib/cocoapods/sled.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "sled/version"
+
+module Cocoapods
+  module Sled
+    class Error < StandardError; end
+    # Your code goes here...
+  end
+end

data/lib/cocoapods-sled/command/install/device.rb

@@ -0,0 +1,31 @@
+module Pod
+  class Command
+    class Install < Command
+      class Device < Install
+        require 'cocoapods-sled/installer_options'
+        require 'cocoapods-sled/command/options/sled_options'
+
+        include SledOptions
+
+        self.summary = '查找真机二进制缓存'
+
+        self.description = <<-DESC
+          #{self.summary}，缓存目录: `#{Config.instance.cache_root + 'Frameworks'}`.
+        DESC
+
+        def initialize(argv)
+          super
+        end
+
+        def validate!
+          super
+        end
+
+        def run
+          Pod::Installer.sled_reuse_type = :device
+          super
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-sled/command/install/simulator.rb

@@ -0,0 +1,32 @@
+module Pod
+  class Command
+    class Install < Command
+      class Simulator < Install
+        require 'cocoapods-sled/installer_options'
+
+        require 'cocoapods-sled/command/options/sled_options'
+
+        include SledOptions
+
+        self.summary = '查找模拟器二进制缓存'
+
+        self.description = <<-DESC
+          #{self.summary}，缓存目录: `#{Config.instance.cache_root + 'Frameworks'}`.
+        DESC
+
+        def initialize(argv)
+          super
+        end
+
+        def validate!
+          super
+        end
+
+        def run
+          Pod::Installer.sled_reuse_type = :simulator
+          super
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-sled/command/options/sled_options.rb

@@ -0,0 +1,68 @@
+require 'cocoapods-sled/podfile/dsl_ext'
+require 'cocoapods-sled/framework_cache'
+
+module Pod
+  class Command
+    module Options
+      module SledOptions
+
+        module Options
+          def options
+            [
+              ['--no-binary-pods=name', '禁用指定的 Pod 二进制缓存，多个 Pod 名称用","分隔, 优先级高于 --all-binary'],
+              ['--all-binary', '强制使用二进制缓存，忽略 Podfile 中 `:binary` 设置'],
+              ['--header-search-path', '生成 Header Search Path，一般用于打包机'],
+              ['--project=name', '工程名称，用于生成framework缓存目录，区分多个工程的缓存'],
+              ['--no-dev-pod', '关闭 Development Pods 二进制缓存，默认是开启的'],
+              ['--force-sync-dev-pod', '强制缓存 Development Pods 编译结果，忽略本地修改检查，默认本地有修改时不缓存，一般用于打包机'],
+              ['--inhibit-all-warnings', '强制关闭警告，忽略 Podfile 中的配置，一般用于打包机'],
+              ['--cache-limit=num', '指定每个 Pod 缓存存储上限数量，小于 3 无效，一般用于打包机'],
+              ['--dep-check=[single|all]', '检查依赖库版本是否发生变更，single：只检查直接依赖，all：检查全部依赖，一般用于打包机'],
+              ['--check-xcode-version', '检查xcode版本，不同版本打包不复用，使用 xcodebuild -version 获取版本信息，一般用于打包机'],
+              ['--configuration=[Debug|Release|自定义]', '编译配置用于生产缓存路径(Debug、Release、自定义)，不传则不区分共用，一般用于打包机']
+            ].concat(super)
+          end
+        end
+
+        def self.included(base)
+          base.extend(Options)
+        end
+
+        def initialize(argv)
+          Podfile::DSL.sled_disable_binary_pods = argv.option('no-binary-pods', '').split(',')
+          count = argv.option('cache-limit', '').to_i
+          if !count.nil? && count >= 3 
+            FrameworkCache.sled_cache_limit = count
+          end
+
+          check_type = argv.option('dep-check', '').to_sym
+          if VALID_DEPENDENCY_CHECK_TYPE.include? check_type
+            Podfile::DSL.dependency_check_type = check_type
+          end
+
+          Podfile::DSL.sled_configuration = argv.option('configuration', DEFAULT_CONFIGURATION).to_s
+
+          Podfile::DSL.sled_project_name = argv.option('project', '')
+           
+          Installer.sled_force_binary = argv.flag?('all-binary', false)
+          if argv.flag?('header-search-path', false)
+            Podfile::DSL.sled_enable_generate_header_search_paths = true
+          end
+          if argv.flag?('no-dev-pod', false)
+            Podfile::DSL.sled_disable_binary_cache_for_dev_pod = true
+          end
+          if argv.flag?('force-sync-dev-pod', false)
+            Installer.sled_force_rsync_local_pod = true
+          end
+          if argv.flag?('inhibit-all-warnings', false)
+            Podfile::DSL.sled_inhibit_all_warnings = true
+          end
+          if argv.flag?('check-xcode-version', false)
+            Podfile::DSL.sled_check_xcode_version = true
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-sled/command.rb

@@ -0,0 +1,2 @@
+require 'cocoapods-sled/command/install/device'
+require 'cocoapods-sled/command/install/simulator'

data/lib/cocoapods-sled/framework_cache.rb

@@ -0,0 +1,147 @@
+require 'fileutils'
+require 'tmpdir'
+
+module Pod
+  # The class responsible for managing Pod downloads, transparently caching
+  # them in a cache directory.
+  #
+  class FrameworkCache
+
+    class_attr_accessor :sled_cache_limit
+    self.sled_cache_limit = 4
+
+    # @return [Pathname] The root directory where this cache store its
+    #         downloads.
+    #
+    attr_reader :root
+
+    # Initialize a new instance
+    #
+    # @param  [Pathname,String] root
+    #         see {#root}
+    #
+    def initialize()
+      @root = Pathname(Config.instance.cache_root + 'Frameworks')
+    end
+
+    def path_for_framework(slug)
+      root + slug
+    end
+
+    def remove_size_exceeded_values(request)
+      pod_cache_dir = root + request.sled_cache_subpath
+      return unless pod_cache_dir.directory?
+
+      array = pod_cache_dir.children.select { |pn| pn.directory? }.sort { |a, b| a.mtime <=> b.mtime }
+      limit = FrameworkCache.sled_cache_limit
+      if array.count > limit # 数量支持配置
+        array.take(array.count - limit).each { |pn| `rm -dr #{pn.to_s}` } # 权限问题
+      end
+    end
+
+    # @param  [Request] request
+    #         the request to be downloaded.
+    #
+    # @return [Response] The download response for the given `request` that
+    #         was found in the download cache.
+    #
+    def cached_pod(request)
+      cached_spec = cached_spec(request)
+      path = path_for_pod(request)
+
+      return unless cached_spec && path.directory?
+      spec = request.spec || cached_spec
+      Response.new(path, spec, request.params)
+    end
+
+    # Copies the `source` directory to `destination`, cleaning the directory
+    # of any files unused by `spec`.
+    #
+    # @param  [Pathname] source
+    #
+    # @param  [Pathname] destination
+    #
+    # @param  [Specification] spec
+    #
+    # @return [Void]
+    #
+    def copy_and_clean(source, destination, spec)
+      specs_by_platform = group_subspecs_by_platform(spec)
+      destination.parent.mkpath
+      FileUtils.rm_rf(destination)
+      FileUtils.cp_r(source, destination)
+      Pod::Installer::PodSourcePreparer.new(spec, destination).prepare!
+      Sandbox::PodDirCleaner.new(destination, specs_by_platform).clean!
+    end
+
+    def group_subspecs_by_platform(spec)
+      specs_by_platform = {}
+      [spec, *spec.recursive_subspecs].each do |ss|
+        ss.available_platforms.each do |platform|
+          specs_by_platform[platform] ||= []
+          specs_by_platform[platform] << ss
+        end
+      end
+      specs_by_platform
+    end
+
+    # Writes the given `spec` to the given `path`.
+    #
+    # @param  [Specification] spec
+    #         the specification to be written.
+    #
+    # @param  [Pathname] path
+    #         the path the specification is to be written to.
+    #
+    # @return [Void]
+    #
+    def write_spec(spec, path)
+      path.dirname.mkpath
+      path.open('w') { |f| f.write spec.to_pretty_json }
+    end
+
+    # @return [Hash<String, Hash<Symbol, String>>]
+    #         A hash whose keys are the pod name
+    #         And values are a hash with the following keys:
+    #         :spec_file : path to the spec file
+    #         :name      : name of the pod
+    #         :version   : pod version
+    #         :release   : boolean to tell if that's a release pod
+    #         :slug      : the slug path where the pod cache is located
+    #
+    def cache_descriptors_per_pod
+      specs_dir = root + 'Specs'
+      release_specs_dir = specs_dir + 'Release'
+      return {} unless specs_dir.exist?
+
+      spec_paths = specs_dir.find.select { |f| f.fnmatch('*.podspec.json') }
+      spec_paths.reduce({}) do |hash, spec_path|
+        spec = Specification.from_file(spec_path)
+        hash[spec.name] ||= []
+        is_release = spec_path.to_s.start_with?(release_specs_dir.to_s)
+        request = Downloader::Request.new(:spec => spec, :released => is_release)
+        hash[spec.name] << {
+          :spec_file => spec_path,
+          :name => spec.name,
+          :version => spec.version,
+          :release => is_release,
+          :slug => root + request.slug,
+        }
+        hash
+      end
+    end
+  end
+
+  module Downloader
+    class Request
+      def sled_cache_subpath(name: self.name)
+
+        if released_pod?
+          "Release/#{name}"
+        else
+          "External/#{name}"
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-sled/gem_version.rb

@@ -0,0 +1,7 @@
+module Pod
+  module Sled 
+    # The version of the CocoaPods-sled plug-in.
+    #
+    VERSION = '0.0.1'.freeze unless defined? Pod::Sled::VERSION
+  end
+end

data/lib/cocoapods-sled/installer_options.rb

@@ -0,0 +1,49 @@
+require_relative 'tool'
+require_relative 'podfile/dsl_ext'
+
+module Pod
+  class Installer
+
+    class_attr_accessor :sled_force_rsync_local_pod
+    self.sled_force_rsync_local_pod = false
+
+    # MARK: force_binary
+    class_attr_accessor :sled_force_binary
+    self.sled_force_binary = false
+
+    # MARK: sled_reuse_type
+    # @return [Array<Symbol>] known reuse options.
+    #
+    KNOWN_REUSE_OPTIONS = %i(device simulator).freeze
+
+    class_attr_accessor :sled_reuse_type
+    self.sled_reuse_type = nil
+
+    def self.sled_should_resure?
+      sled_reuse_type && KNOWN_REUSE_OPTIONS.include?(sled_reuse_type)
+    end
+
+    def self.sled_reuse_type_name       
+      case sled_reuse_type
+      when :device then
+        "#{Podfile::DSL.sled_configuration}-iphoneos"
+      when :simulator then
+        "#{Podfile::DSL.sled_configuration}-iphonesimulator"
+      else
+        "Other"
+      end
+    end
+
+    def self.sled_reuse_type_desc 
+      case sled_reuse_type
+      when :device then
+        "真机"
+      when :simulator then
+        "模拟器"
+      else
+        "Other"
+      end
+    end
+
+  end
+end

data/lib/cocoapods-sled/integration.rb

@@ -0,0 +1,257 @@
+require_relative 'framework_cache'
+require_relative 'tool'
+require_relative 'sandbox/path_list_ext'
+require_relative 'podfile/dsl_ext'
+require_relative 'target/pod_target_ext'
+
+module Pod
+    class Target
+
+        def sled_sepc_full_name 
+            name = specs.sort_by(&:name)
+                .map { |spec| spec.name.sub("#{root_spec.name}/", "").gsub("/", "-") }
+                .join("-") # 区分不同subspec打包的framework
+            name = root_spec.name + "-" + name if !name.include?(root_spec.name)
+            # File name too long
+            if name.length > 50 
+                name = Digest::MD5.hexdigest(name)
+            end
+            name
+        end 
+        
+        # 如果 Podfile 中重写了 build_as_static_framework? build_as_dynamic_framework?，但是没有修改 @build_type
+        # verify_no_static_framework_transitive_dependencies 执行时，需要编译的pod库都按照修改前的build_type检查
+        # 导致判断有问题报错：动态库不能依赖静态库
+        # The 'Pods-xxx' target has transitive dependencies that include statically linked binaries: 
+        def sled_adjust_build_type
+            if build_as_static_framework?
+                @build_type = BuildType.static_framework
+            elsif build_as_dynamic_framework?
+                @build_type = BuildType.dynamic_framework
+            end
+        end
+
+        def sled_build_type_name
+            "#{build_type.linkage}_#{build_type.packaging}"
+        end
+
+        def sled_framework_cache_subpath(reuse_type_name)
+            "#{sled_build_type_name}/#{sled_sepc_full_name}/#{reuse_type_name}"
+        end
+    end
+end
+
+module Pod
+    class Installer
+        require 'cocoapods-sled/installer_options'
+
+        SLED_VALID_PLATFORMS = Platform.all.freeze.map { |v| v.name.to_s }
+
+        def f_cache
+            @f_cache ||= FrameworkCache.new
+        end
+
+        old_install_pod_sources = instance_method(:download_dependencies)
+        define_method(:download_dependencies) do 
+            old_install_pod_sources.bind(self).()
+
+            # Installer.sled_reuse_type = :device
+            return unless Installer.sled_should_resure?
+
+            UI.section "查找#{Installer.sled_reuse_type_desc} Sled 缓存" do
+                sled_reuse_action
+            end
+        end
+
+        def sled_reuse_action
+            cache = []
+
+            sled_totalTargets = []
+            @sled_hits = []
+            @sled_miss = []
+            disable_binary_pod_targets = []
+
+            pod_targets.each do |target|
+                # 修正build_type
+                # target.sled_adjust_build_type
+
+                disable_binary_pod_targets << target.name if Podfile::DSL.sled_disable_binary_pods.include?(target.root_spec.name)
+                next if Podfile::DSL.sled_disable_binary_pods.include?(target.root_spec.name)
+
+                disable_binary_pod_targets << target.name if target.seld_ignore_binary?
+                next if target.seld_ignore_binary?
+
+                disable_binary_pod_targets << target.name unless Pod::Installer.sled_force_binary || target.sled_enable_binary?
+                next unless Pod::Installer.sled_force_binary || target.sled_enable_binary?
+
+                root_spec = target.root_spec
+
+
+                sled_totalTargets << target.name 
+                
+                if target.sled_local?
+                    return if Podfile::DSL.sled_disable_binary_cache_for_dev_pod
+                    sled_modify_pod_target(target)
+                else
+                    sled_modify_pod_target(target)
+                end
+            end
+            
+            UI.puts " -> pod targets数量: #{pod_targets.count}".yellow
+            UI.puts " -> binary disabled数量: #{disable_binary_pod_targets.count}".yellow
+            disable_binary_pod_targets_text = disable_binary_pod_targets.join(", ")
+            UI.puts "    #{disable_binary_pod_targets_text}" unless disable_binary_pod_targets_text.empty?
+            UI.puts " -> 处理targets数量: #{sled_totalTargets.count}".yellow
+            UI.puts " -> 命中数量: #{@sled_hits.count}".yellow
+            UI.message "    #{@sled_hits.join(", ")}"
+            UI.puts " -> 未命中数量: #{@sled_miss.count}".yellow
+            sled_miss_text = @sled_miss.join(", ")
+            UI.puts "    #{sled_miss_text}" unless sled_miss_text.empty?
+        end
+
+        def xcode_version
+            @xcode_version ||= `xcodebuild -version | grep "Build version" | awk '{print $NF}' | head -1`.strip
+        end
+
+        def sled_modify_pod_target(target)
+            request = target.sled_download_request
+            return if request.nil?
+
+            root_spec = target.root_spec
+
+            slug = target.sled_slug_current
+            if Podfile::DSL.sled_check_xcode_version
+                slug = "#{slug}-#{xcode_version}"
+            end
+            unless Podfile::DSL.sled_project_name.empty?
+                slug = "#{slug}-#{Podfile::DSL.sled_project_name}"
+            end
+
+            path = f_cache.path_for_framework(slug)
+            
+            pod_root = sandbox.pod_dir(root_spec.name)
+
+            framework_dir_path = path + target.sled_framework_cache_subpath(Installer.sled_reuse_type_name)
+            framework_file_path = framework_dir_path + target.product_name  
+        
+            if framework_file_path.directory?
+                path.utime(Time.now, Time.now)
+
+                @sled_hits << target.name
+
+                # 1.12.x 相同 pod_root 重用了 path_list，这里会导致同目录下的podspec只能找到一个二进制
+                target.file_accessors.map(&:path_list).each do |value|
+                    value.add_cache_root(framework_dir_path)
+                end
+
+                framework_dir_relative_path = framework_dir_path.relative_path_from(pod_root)
+                framework_file_relative_path = framework_file_path.relative_path_from(pod_root)
+
+                target.specs.each do |spec|
+
+                    sled_empty_source_files(spec)
+                    sled_add_vendered_framework(spec, framework_file_relative_path.to_s)
+                    sled_replace_resource_bundles(spec, framework_dir_relative_path.to_s)
+                    sled_add_header_search_paths(spec, target, framework_file_path.to_s)
+                end
+            else
+                @sled_miss << target.name
+                sled_add_script_phases(target, path)
+            end
+
+            f_cache.remove_size_exceeded_values(request)
+        end
+
+        def sled_add_header_search_paths(spec, pod_target, framework_file_path)
+            return unless pod_target.sled_enable_generate_header_search_paths?
+
+            spec.attributes_hash["user_target_xcconfig"] ||= {}
+            spec.attributes_hash["user_target_xcconfig"]["HEADER_SEARCH_PATHS"] = "#{framework_file_path}/Headers/"
+            # "${PODS_ROOT}/#{target.copy_resources_script_path_for_spec(spec).relative_path_from(target.sandbox.root)}"
+        end
+
+        def sled_replace_resource_bundles(spec, framework_dir_path)
+            if spec.attributes_hash["resource_bundles"]
+                bundle_names = spec.attributes_hash["resource_bundles"].keys
+                spec.attributes_hash["resource_bundles"] = nil 
+
+                spec.attributes_hash["resources"] = Array(spec.attributes_hash["resources"])
+                spec.attributes_hash["resources"] += bundle_names.map{ |name| "#{framework_dir_path}/#{name}.bundle" }
+            end
+        end
+        
+        # TODO: 待完善 参考 add_vendered_framework
+        def sled_add_vendered_framework(spec, framework_file_path)
+
+            spec.attributes_hash["vendored_frameworks"] = Array(spec.attributes_hash["vendored_frameworks"])
+            spec.attributes_hash["vendored_frameworks"] += [framework_file_path]
+
+            # spec.attributes_hash["source_files"] = framework_file_path + '/Headers/*.h'
+            # spec.attributes_hash["public_header_files"] = framework_file_path + '/Headers/*.h'
+            spec.attributes_hash["subspecs"] = nil
+        end
+
+        # source_files 置空
+        def sled_empty_source_files(spec)
+            spec.attributes_hash["source_files"] = []
+            spec.attributes_hash["public_header_files"] = []
+            # VALID_PLATFORMS = Platform.all.freeze
+            SLED_VALID_PLATFORMS.each do |plat|
+                if spec.attributes_hash[plat] != nil
+                    spec.attributes_hash[plat]["source_files"] = []
+                    spec.attributes_hash[plat]["public_header_files"] = []
+                end
+            end
+        end
+
+        def sled_add_script_phases(pod_target, chche_dir)
+
+            rsync_func = ""
+
+            # Local Pod不强制同步时，检查本地代码变更
+            if pod_target.sled_local? && !Installer.sled_force_rsync_local_pod
+                pod_target.sled_local_pod_paths.each do |path|
+                    rsync_func << <<-SH.strip_heredoc
+                    status=`git -C #{path} status -s #{path}`
+                    
+                    if [[ $status != "" ]]; then
+                        echo "#{pod_target.name} 有变更，不同步编译结果"
+                        echo $status
+                        exit 0
+                    fi
+
+                    SH
+                end
+            end
+
+            rsync_func << "#{Pod::Generator::ScriptPhaseConstants::RSYNC_PROTECT_TMP_FILES}"
+            rsync_func << <<-SH.strip_heredoc
+
+                framework_cache_path="#{chche_dir}/#{pod_target.sled_framework_cache_subpath("${CONFIGURATION}${EFFECTIVE_PLATFORM_NAME}")}"
+                common_cache_path="#{chche_dir}/#{pod_target.sled_framework_cache_subpath("#{DEFAULT_CONFIGURATION}${EFFECTIVE_PLATFORM_NAME}")}"
+
+                echo "mkdir -p ${framework_cache_path}" || true
+                mkdir -p ${framework_cache_path}
+
+                exec_rsync() {
+                    echo "rsync -rLptgoDv --chmod=a=rwx "${RSYNC_PROTECT_TMP_FILES[@]}" ${CONFIGURATION_BUILD_DIR}/ ${framework_cache_path} &"
+
+                    # TARGET_BUILD_DIR 在打包机上有问题，包含所有Framework，使用CONFIGURATION_BUILD_DIR
+                    rsync -rLptgoDv --chmod=a=rwx "${RSYNC_PROTECT_TMP_FILES[@]}" "${CONFIGURATION_BUILD_DIR}/" "${framework_cache_path}" >/dev/null 2>>"#{chche_dir}/error.log"
+
+                    ln -sfn "${framework_cache_path}" "${common_cache_path}"
+                }
+
+                (exec_rsync) &
+            SH
+
+            spec = pod_target.specs.first
+            value = Array(spec.attributes_hash['script_phases'] || spec.attributes_hash['script_phase'])
+            value << {
+                :name => "Rsync Framework And Bundle To Sled Cache",
+                :script => rsync_func
+            }
+            spec.attributes_hash["script_phases"] = value
+        end
+    end
+end

data/lib/cocoapods-sled/podfile/dsl_ext.rb

@@ -0,0 +1,62 @@
+require_relative '../tool'
+
+VALID_DEPENDENCY_CHECK_TYPE = %i(default single all).freeze
+DEFAULT_CONFIGURATION = "Sled-Common"
+
+module Pod    
+    class Podfile
+        module DSL
+
+            # def sled_enable_binary_cache!
+            #     DSL.sled_enable_binary_cache = true
+            # end
+
+            def sled_disable_binary_cache_for_dev_pod!
+                DSL.sled_disable_binary_cache_for_dev_pod = true
+            end
+
+            def sled_enable_generate_header_search_paths!
+                DSL.sled_enable_generate_header_search_paths = true
+            end
+
+            def sled_disable_binary_pods(*names)
+                DSL.sled_disable_binary_pods ||= []
+                DSL.sled_disable_binary_pods.concat(names)
+            end 
+
+            private
+            # 开启二进制缓存(默认开启，暂时不支持修改)
+            class_attr_accessor :sled_enable_binary_cache
+            self.sled_enable_binary_cache = true
+
+            # 禁用 Development pods 二进制缓存
+            class_attr_accessor :sled_disable_binary_cache_for_dev_pod
+            self.sled_disable_binary_cache_for_dev_pod = false
+
+            # 生成 HEADER_SEARCH_PATHS
+            class_attr_accessor :sled_enable_generate_header_search_paths
+            self.sled_enable_generate_header_search_paths = false
+
+            class_attr_accessor :sled_inhibit_all_warnings
+            self.sled_inhibit_all_warnings = false
+
+            class_attr_accessor :sled_disable_binary_pods
+            self.sled_disable_binary_pods = []
+
+            class_attr_accessor :dependency_check_type
+            self.dependency_check_type = :default
+
+            # 检查 xcode 版本，使用 xcodebuild -version 获取版本信息 Build version
+            class_attr_accessor :sled_check_xcode_version
+            self.sled_check_xcode_version = false
+
+            # 工程名称，用于生成缓存目录，区分多个工程的缓存
+            class_attr_accessor :sled_project_name
+            self.sled_project_name = ''
+
+            # 编译配置，用于生成缓存目录，默认不区分不同的编译配置(Debug | Release | 自定义)
+            class_attr_accessor :sled_configuration
+            self.sled_configuration = DEFAULT_CONFIGURATION
+        end
+    end
+end

data/lib/cocoapods-sled/podfile/target_definition_ext.rb

@@ -0,0 +1,74 @@
+module Pod
+  class Podfile
+    class SLEDPodOptionsItem
+
+      attr_reader :internal_hash
+      attr_reader :key
+      attr_reader :default
+
+      def initialize(key, default)
+        @internal_hash = {}
+        @key = key
+        @default = default
+      end
+
+      def value_for_pod(pod_name)
+        value = internal_hash[pod_name] || [default]
+        value.map do |v|  
+          v.nil? ? default : v
+        end
+      end
+
+      # def sled_all_vlaue=(flag)
+      #   internal_hash['all'] = flag
+      # end
+
+      def set_value_for_pod(pod_name, value)
+        internal_hash[pod_name] ||= []
+        internal_hash[pod_name] << value
+      end
+
+      def parse_options(name, requirements)
+        options = requirements.last
+        return requirements unless options.is_a?(Hash)
+
+        should_enable = options.delete(key)
+        pod_name = Specification.root_name(name)
+        set_value_for_pod(pod_name, should_enable)
+
+        requirements.pop if options.empty?
+      end
+    end
+
+    class TargetDefinition
+      def sled_option_binary 
+        @sled_option_binary = SLEDPodOptionsItem.new(:binary, nil) unless @sled_option_binary
+        @sled_option_binary
+      end
+
+      def sled_option_header_search_paths
+        @sled_option_header_search_paths = SLEDPodOptionsItem.new(:hsp, nil) unless @sled_option_header_search_paths
+        @sled_option_header_search_paths
+      end 
+
+      def sled_parse_sled_options(name, requirements)
+        sled_option_binary.parse_options(name, requirements)
+        sled_option_header_search_paths.parse_options(name, requirements)
+      end
+
+      def sled_inhibit_warnings_if_needed(name, requirements)
+        return requirements unless Podfile::DSL.sled_inhibit_all_warnings
+        options = requirements.last
+        return requirements unless options.is_a?(Hash)
+        options[:inhibit_warnings] = true
+      end
+
+      original_parse_inhibit_warnings = instance_method(:parse_inhibit_warnings)
+      define_method(:parse_inhibit_warnings) do |name, requirements|
+        sled_parse_sled_options(name, requirements)
+        sled_inhibit_warnings_if_needed(name, requirements)
+        original_parse_inhibit_warnings.bind(self).call(name, requirements)
+      end
+    end
+  end
+end

data/lib/cocoapods-sled/sandbox/path_list_ext.rb

@@ -0,0 +1,55 @@
+require_relative '../tool'
+
+module Pod
+    class Sandbox
+        class PathList
+            attr_accessor :sled_framework_cache_roots
+
+            old_read_file_system = instance_method(:read_file_system)
+            define_method(:read_file_system) do 
+                old_read_file_system.bind(self).()
+
+                return if sled_framework_cache_roots.nil? || sled_framework_cache_roots.empty?
+                sled_framework_cache_roots.each do |root|
+                  sled_read_framework_file_system(root) 
+                end
+            end
+
+            def add_cache_root(root)
+              @sled_framework_cache_roots ||= [] 
+              @sled_framework_cache_roots << root unless @sled_framework_cache_roots.include?(root)
+            end
+
+            def sled_read_framework_file_system(path)
+                unless path.exist?
+                  # raise Informative, "Attempt to read non existent folder `#{root}`."
+                  Pod::UI.puts "⚠️⚠️⚠️ Attempt to read non existent folder `#{path}`."
+                  return
+                end
+        
+                prefix = path.relative_path_from(root)
+        
+                dirs = []
+                files = []
+                root_length = path.cleanpath.to_s.length + File::SEPARATOR.length
+                escaped_root = escape_path_for_glob(path)
+                Dir.glob(escaped_root + '**/*', File::FNM_DOTMATCH).each do |f|
+                  directory = File.directory?(f)
+                  # Ignore `.` and `..` directories
+                  next if directory && f =~ /\.\.?$/
+        
+                  f = f.slice(root_length, f.length - root_length)
+                  next if f.nil?
+        
+                  (directory ? dirs : files) << (prefix + f).to_s
+                end
+        
+                dirs.sort_by!(&:upcase)
+                files.sort_by!(&:upcase)
+        
+                @dirs = @dirs + dirs
+                @files = @files + files
+              end
+        end
+    end
+end

data/lib/cocoapods-sled/target/pod_target_ext.rb

@@ -0,0 +1,164 @@
+require_relative '../podfile/target_definition_ext'
+require 'digest'
+
+module Pod
+  class PodTarget < Target
+
+    def sled_enable_generate_header_search_paths?
+      return @sled_enable_generate_header_search_paths if defined? @sled_enable_generate_header_search_paths
+      whitelists = target_definitions.map do |target_definition|
+        target_definition.sled_option_header_search_paths.value_for_pod(root_spec.name)
+      end.flatten.uniq.reject { |element| element == nil }
+
+      if whitelists.empty?
+        @sled_enable_generate_header_search_paths = Podfile::DSL.sled_enable_generate_header_search_paths
+      elsif whitelists.count == 1
+        @sled_enable_generate_header_search_paths = !!whitelists.first
+      else
+        value = whitelists.first
+        tmp_td = target_definitions
+          .detect { |obj| obj.sled_option_header_search_paths.value_for_pod(root_spec.name).first == value }
+        target_name = tmp_td == nil ? "unknown" : tmp_td.name
+        UI.warn "The pod `#{pod_name}` is linked to different targets " \
+          "(#{target_definitions.map { |td| "`#{td.name}`" }.to_sentence}), which contain different " \
+          'settings to hsp. CocoaPods does not currently ' \
+          'support different settings and will fall back to your preference ' \
+          "set in the `#{target_name}` target definition" \
+          " :hsp => #{value}."
+        @sled_enable_generate_header_search_paths = !!value
+      end
+      @sled_enable_generate_header_search_paths
+    end
+
+    def seld_ignore_binary?
+      sled_option_binary_value == :ignore
+    end
+
+    def sled_enable_binary?
+      sled_option_binary_value == true
+    end
+
+    def sled_option_binary_value
+      return @sled_option_binary_value if defined? @sled_option_binary_value
+      whitelists = target_definitions.map do |target_definition|
+        target_definition.sled_option_binary.value_for_pod(root_spec.name)
+      end.flatten.uniq.reject { |element| element == nil }
+
+      if whitelists.empty?
+        @sled_option_binary_value = Podfile::DSL.sled_enable_binary_cache
+      elsif whitelists.count == 1
+        @sled_option_binary_value = whitelists.first
+      else
+        value = whitelists.first
+        tmp_td = target_definitions
+          .detect { |obj| obj.sled_option_binary.value_for_pod(root_spec.name).first == value }
+        target_name = tmp_td == nil ? "unknown" : tmp_td.name
+        UI.warn "The pod `#{pod_name}` is linked to different targets " \
+          "(#{target_definitions.map { |td| "`#{td.name}`" }.to_sentence}), which contain different " \
+          "settings to binary. CocoaPods does not currently " \
+          'support different settings and will fall back to your preference ' \
+          "set in the `#{target_name}` target definition" \
+          " :binary => #{value}."
+        @sled_option_binary_value = value
+      end
+      @sled_option_binary_value
+    end
+
+    def sled_predownloaded?
+      sandbox.predownloaded_pods.include?(root_spec.name)
+    end
+
+    def sled_local?
+      sandbox.local?(root_spec.name)
+    end
+
+    def sled_released?
+      !sled_local? && !sled_predownloaded? && sandbox.specification(root_spec.name) != root_spec
+    end
+
+    def sled_local_pod_paths
+      paths = []
+      paths =file_accessors.map(&:path_list).map(&:root).uniq if sled_local?
+      paths
+    end
+
+    def sled_slug_current 
+      case Podfile::DSL.dependency_check_type
+      when :single
+        sled_plain_slug
+      when :all
+        sled_complex_slug
+      else
+        sled_slug
+      end
+    end
+
+    # 不检查依赖
+    def sled_slug
+      @sled_slug ||= sled_download_request.slug
+      @sled_slug
+    end
+
+    # 检查直接依赖
+    def sled_plain_slug
+      if dependent_targets.empty?
+        @sled_plain_slug ||= sled_slug
+      else 
+        if @sled_plain_slug.nil?
+          tmp_slug = dependent_targets.map { |t| t.sled_slug }.join("-")
+          @sled_plain_slug = "#{sled_slug}-#{Digest::MD5.hexdigest(tmp_slug)}"
+        end
+      end
+      @sled_plain_slug
+    end
+
+    # 检查全部依赖
+    def sled_complex_slug
+      if dependent_targets.empty?
+        @sled_complex_slug ||= sled_slug
+      else 
+        if @sled_complex_slug.nil?
+          tmp_slug = dependent_targets.map { |t| t.sled_complex_slug }.join("-")
+          @sled_complex_slug = "#{sled_slug}-#{Digest::MD5.hexdigest(tmp_slug)}"
+        end
+      end
+      @sled_complex_slug
+    end
+
+    def sled_download_request
+      if sled_local?
+        commit_id = file_accessors
+          .map(&:path_list)
+          .map(&:root).uniq
+          .map do |path|
+              `git -C #{path} log -1 --pretty=format:%H #{path} 2>/dev/null`
+          end
+          .join("")
+
+        if commit_id.empty?
+          request = nil
+        else 
+          params = { :commit => commit_id }
+          request = Downloader::Request.new(
+              :name => root_spec.name,
+              :params => params,
+          )
+        end
+      elsif sandbox.checkout_sources && sandbox.checkout_sources.keys.include?(root_spec.name)
+          params = sandbox.checkout_sources[root_spec.name]
+
+          request = Downloader::Request.new(
+              :name => root_spec.name,
+              :params => params,
+          )
+      else
+          request = Downloader::Request.new(
+              :spec => root_spec,
+              :released => sled_released?,
+          )
+      end
+
+      request
+    end
+  end
+end

data/lib/cocoapods-sled/tool.rb

@@ -0,0 +1,12 @@
+# attr_accessor for class variable.
+# usage:
+#
+#   ```
+#   class Pod
+#       class_attr_accessor :is_prebuild_stage
+#   end
+#   ```
+#
+def class_attr_accessor(symbol)
+    self.class.send(:attr_accessor, symbol)
+end

data/lib/cocoapods-sled.rb

@@ -0,0 +1 @@
+require 'cocoapods-sled/gem_version'

data/lib/cocoapods_plugin.rb

@@ -0,0 +1,2 @@
+require 'cocoapods-sled/command'
+require 'cocoapods-sled/integration'

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: cocoapods-sled
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- 赵守文
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-05-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "  Cocoapods-sled 是一款轻量级且易于使用的Cocoapods插件，旨在通过二进制化处理提升项目构建速度。它的核心优势在于：\n
+  \ \n  1. **编译结果缓存**：利用缓存机制，复用编译结果，避免不必要的重复编译，从而提高开发效率。\n  2. **二进制化处理**：自动将可复用的依赖项转换为二进制格式，提升构建速度。\n
+  \ 3. **低接入成本**：易于集成，开发者可以快速将其加入到现有的Xcode项目中，无需复杂的配置和基建即可开始优化构建流程。\n  \n  Cocoapods-sled
+  致力于成为iOS项目构建优化的首选工具，帮助开发者以更低的成本实现更高效的开发流程。\n"
+email:
+- zsw19911017@163.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cocoapods-sled.rb
+- lib/cocoapods-sled/command.rb
+- lib/cocoapods-sled/command/install/device.rb
+- lib/cocoapods-sled/command/install/simulator.rb
+- lib/cocoapods-sled/command/options/sled_options.rb
+- lib/cocoapods-sled/framework_cache.rb
+- lib/cocoapods-sled/gem_version.rb
+- lib/cocoapods-sled/installer_options.rb
+- lib/cocoapods-sled/integration.rb
+- lib/cocoapods-sled/podfile/dsl_ext.rb
+- lib/cocoapods-sled/podfile/target_definition_ext.rb
+- lib/cocoapods-sled/sandbox/path_list_ext.rb
+- lib/cocoapods-sled/target/pod_target_ext.rb
+- lib/cocoapods-sled/tool.rb
+- lib/cocoapods/sled.rb
+- lib/cocoapods/sled/version.rb
+- lib/cocoapods_plugin.rb
+homepage: https://github.com/git179979506/cocoapods-sled
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/git179979506/cocoapods-sled
+  source_code_uri: https://github.com/git179979506/cocoapods-sled
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Cocoapods-sled：一个轻量级且高效的Cocoapods插件，实现二进制化功能。
+test_files: []