cocoapods-headermap 1.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 03773ea3588ccfd9fc4f5be042da14a89b41134922afa52c7eec230370014a06
+  data.tar.gz: b13fe6e18cf5571eefdc4314bccd88106d39442fcbaded7906a1e7c2690b5a03
+SHA512:
+  metadata.gz: 9ade511448e2ab9b3d380604a1114ab9eb36120847ad2f37867102297cdf06589580e148f528b1df177c9f5700053372735f005c7adc52fa09e416e73d9670bc
+  data.tar.gz: eee532c7e86bfb62dcb4fc0839e077c23e3546d9d100c9f5174277ec495c25d498750d4661cd9190539bee5509943bc86a09d4fafbd3bac5fd07b32b5013f435

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+pkg
+.idea/

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cocoapods-headermap.gemspec
+gemspec
+
+group :development do
+  gem 'cocoapods'
+
+  gem 'mocha'
+  gem 'bacon'
+  gem 'mocha-on-bacon'
+  gem 'prettybacon'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2021 menttofly <1028365614@qq.com>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,13 @@
+# cocoapods-headermap
+
+[![Gem Version](https://badge.fury.io/rb/cocoapods-headermap.svg)](https://badge.fury.io/rb/cocoapods-headermap)
+
+A description of cocoapods-headermap.
+
+## Installation
+
+    $ gem install cocoapods-headermap
+
+## Usage
+
+    $ pod spec headermap POD_NAME

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+
+def specs(dir)
+  FileList["spec/#{dir}/*_spec.rb"].shuffle.join(' ')
+end
+
+desc 'Runs all the specs'
+task :specs do
+  sh "bundle exec bacon #{specs('**')}"
+end
+
+task :default => :specs
+

data/cocoapods-headermap.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cocoapods-headermap/gem_version.rb'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cocoapods-headermap'
+  spec.version       = CocoapodsHeadermap::VERSION
+  spec.authors       = ['menttofly']
+  spec.email         = ['1028365614@qq.com']
+  spec.description   = %q{Improve Xcode compilation speed based on Header Maps.}
+  spec.summary       = %q{Generate header maps file instead of creating soft link during pod installation. Therefore, file IO can be reduced during the build process and the search speed of header files can be improved.}
+  spec.homepage      = 'https://github.com/'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+end

data/lib/cocoapods-headermap/build_settings.rb

@@ -0,0 +1,63 @@
+require 'cocoapods-headermap/headers_store'
+
+module Pod
+    class Target
+        class BuildSettings
+            class PodTargetSettings < BuildSettings
+
+                # Call `define_build_settings_method` with a given block in order to disable sorting.
+                define_build_settings_method :header_search_paths, :build_setting => true, :memoized => true, :sorted => false do
+                    paths = target.header_search_paths(:include_dependent_targets_for_test_spec => test_xcconfig? && non_library_spec, :include_dependent_targets_for_app_spec => app_xcconfig? && non_library_spec, :configuration => @configuration)
+          
+                    dependent_vendored_xcframeworks = []
+                    dependent_vendored_xcframeworks.concat vendored_xcframeworks
+                    dependent_vendored_xcframeworks.concat dependent_targets.flat_map { |pt| pt.build_settings[@configuration].vendored_xcframeworks }
+                    paths.concat dependent_vendored_xcframeworks.
+                      select { |xcf| xcf.build_type.static_library? }.
+                      map { |xcf| "#{BuildSettings.xcframework_intermediate_dir(xcf)}/Headers" }.
+                      compact
+                    paths
+                end
+
+                # @return [Array<String>] The path of `hmap` file for this project
+                define_build_settings_method :user_header_search_paths, :build_setting => true, :memoized => true, :sorted => false do
+                    paths = ["${PODS_ROOT}/#{target.sandbox.headers_root.basename}/#{Sandbox::POD_PROJECT_HEADERS}.hmap"]
+                    paths
+                end
+            end
+
+            class AggregateTargetSettings < BuildSettings
+                # # Call `define_build_settings_method` with a given block in order to disable sorting paths.
+                define_build_settings_method :header_search_paths, :build_setting => true, :memoized => true, :sorted => false, :uniqued => true do
+                    paths = []
+          
+                    if !target.build_as_framework? || !pod_targets.all?(&:should_build?)
+                      paths.concat target.sandbox.public_headers.search_paths(target.platform)
+                    end
+          
+                    # Make frameworks headers discoverable with any syntax (quotes,
+                    # brackets, @import, etc.)
+                    paths.concat pod_targets.
+                      select { |pt| pt.build_as_framework? && pt.should_build? }.
+                      map { |pt| pt.build_settings[@configuration].framework_header_search_path }
+          
+                    xcframework_library_headers = pod_targets.flat_map { |pt| pt.build_settings[@configuration].vendored_xcframeworks }.
+                                                  select { |xcf| xcf.build_type.static_library? }.
+                                                  map { |xcf| "#{BuildSettings.xcframework_intermediate_dir(xcf)}/Headers" }.
+                                                  compact
+          
+                    paths.concat xcframework_library_headers
+                    paths.concat target.search_paths_aggregate_targets.flat_map { |at| at.build_settings(configuration_name).header_search_paths }
+                    paths
+                end
+
+                # @return [Array<String>] The path of `hmap` file for this project
+                define_build_settings_method :user_header_search_paths, :build_setting => true, :memoized => true, :sorted => false do
+                    paths = ["${PODS_ROOT}/#{target.sandbox.headers_root.basename}/#{Sandbox::POD_PROJECT_HEADERS}.hmap"]
+                    paths
+                end
+            end
+        end
+    end
+end
+    

data/lib/cocoapods-headermap/command/headermap.rb

@@ -0,0 +1,44 @@
+module Pod
+  class Command
+    # This is an example of a cocoapods plugin adding a top-level subcommand
+    # to the 'pod' command.
+    #
+    # You can also create subcommands of existing or new commands. Say you
+    # wanted to add a subcommand to `list` to show newly deprecated pods,
+    # (e.g. `pod list deprecated`), there are a few things that would need
+    # to change.
+    #
+    # - move this file to `lib/pod/command/list/deprecated.rb` and update
+    #   the class to exist in the the Pod::Command::List namespace
+    # - change this class to extend from `List` instead of `Command`. This
+    #   tells the plugin system that it is a subcommand of `list`.
+    # - edit `lib/cocoapods_plugins.rb` to require this file
+    #
+    # @todo Create a PR to add your plugin to CocoaPods/cocoapods.org
+    #       in the `plugins.json` file, once your plugin is released.
+    #
+    class Headermap < Command
+      self.summary = 'Short description of cocoapods-headermap.'
+
+      self.description = <<-DESC
+        Longer description of cocoapods-headermap.
+      DESC
+
+      self.arguments = 'NAME'
+
+      def initialize(argv)
+        @name = argv.shift_argument
+        super
+      end
+
+      def validate!
+        super
+        help! 'A Pod name is required.' unless @name
+      end
+
+      def run
+        UI.puts "Add your implementation for the cocoapods-headermap plugin in #{__FILE__}"
+      end
+    end
+  end
+end

data/lib/cocoapods-headermap/command.rb

@@ -0,0 +1 @@
+require 'cocoapods-headermap/command/headermap'

data/lib/cocoapods-headermap/configuration.rb

@@ -0,0 +1,36 @@
+module Pod 
+    class Configuration
+        # 保存 `$PODS_ROOT/Headers` 目录下所有 Header Search Paths
+        # 始终保留头文件 symlink!!!
+        # 默认为 false
+        @keep_symlink_headers = false
+
+        # 始终保留 symlink & Header Search Paths 的组件
+        # 在 keep_symlink_headers 为 false 时有效
+        @always_keep_symlink_headers = []
+
+        # Multi Pods Project 是否生成 Single Pods Target 不带命名空间的 headers 全集
+        # 默认为 false（暂时无效）
+        @use_legacy_project_headers = false
+        
+        class << self
+            attr_reader :keep_symlink_headers
+            def keep_symlink_headers=(keep_symlink_headers)
+                raise Informative, "[cocoapods-headermap]: Expecting Boolean type for `:keep_symlink_headers`!" unless [true, false].include?(keep_symlink_headers)
+                @keep_symlink_headers = keep_symlink_headers
+            end
+
+            attr_reader :always_keep_symlink_headers
+            def always_keep_symlink_headers=(always_keep_symlink_headers)
+                raise Informative, "[cocoapods-headermap]: Expecting array type for `:always_keep_symlink_headers`!" unless always_keep_symlink_headers.is_a?(Array)
+                @always_keep_symlink_headers.concat always_keep_symlink_headers
+            end
+
+            attr_reader :use_legacy_project_headers
+            def use_legacy_project_headers=(use_legacy_project_headers)
+                raise Informative, "[cocoapods-headermap]: Expecting Boolean type for `:use_legacy_project_headers`!" unless [true, false].include?(use_legacy_project_headers)
+                @use_legacy_project_headers = use_legacy_project_headers
+            end
+        end
+    end
+end

data/lib/cocoapods-headermap/file_references_installer.rb

@@ -0,0 +1,47 @@
+require 'json'
+require 'cocoapods-headermap/header_maps_generator'
+
+module Pod
+    class Installer
+        class Xcode
+            class PodsProjectGenerator
+                class FileReferencesInstaller
+                    
+                    def link_headers
+                        UI.message '- Linking headers' do
+                            pod_targets.each do |pod_target|
+                                next if pod_target.build_as_framework? && pod_target.should_build?
+                                sync_target_info(pod_target)
+                                create_symlink_reference(pod_target)
+                                HeaderMapsGenerator.merge_target_headers(pod_target)
+                            end
+                        end
+                    end
+
+                    def sync_target_info(pod_target)
+                        # pod_target.build_headers.user_clang_module = true if pod_target.file_accessors.first.module_map
+                        pod_target.build_headers.target_name = pod_target.pod_name
+                        sandbox.public_headers.target_name = pod_target.pod_name
+                    end
+
+                    # Creates the link to the headers of the Pod in the sandbox.
+                    def create_symlink_reference(pod_target)
+                        pod_target_header_mappings = pod_target.header_mappings_by_file_accessor.values
+                        pod_target_header_mappings.each do |header_mappings|
+                            header_mappings.each do |namespaced_path, files|
+                                pod_target.build_headers.add_files(namespaced_path, files)
+                            end
+                        end
+
+                        public_header_mappings = pod_target.public_header_mappings_by_file_accessor.values
+                        public_header_mappings.each do |header_mappings|
+                            header_mappings.each do |namespaced_path, files|
+                                sandbox.public_headers.add_files(namespaced_path, files)
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/cocoapods-headermap/gem_version.rb

@@ -0,0 +1,3 @@
+module CocoapodsHeadermap
+  VERSION = "1.0.7"
+end

data/lib/cocoapods-headermap/header_maps_generator.rb

@@ -0,0 +1,168 @@
+module Pod
+    class HeaderMapsGenerator
+        
+        # 所有 target 共享的头文件信息，不带命名空间或路径
+        @all_project_headers = {}
+
+        # 所有 target 公共 header 信息，带命名空间或路径
+        @all_targets_headers = {}
+
+        # Maintains the headers cache for project.
+        @headers_cache = nil
+
+        # Record headers orgnized by target on order to adapt the situation of file change in some targets.
+        @project_headers_by_target = {}
+        @targets_headers_by_target = {}
+
+        # A set of pod target names that were deleted.
+        # Only use for `incremental_installation` enabled.
+        @deleted_pod_targets = Set.new
+
+        class << self
+            attr_accessor :all_project_headers, :all_targets_headers
+            attr_accessor :project_headers_by_target, :targets_headers_by_target
+            attr_accessor :headers_cache
+            attr_reader :deleted_pod_targets
+
+            def deleted_pod_targets=(deleted_pod_target)
+                return if deleted_pod_target.nil?
+                deleted_pod_targets << deleted_pod_target
+            end
+
+            # Generate header map files for all project and targets.
+            def generate!(sandbox, is_legacy_target)
+                UI.puts "[cocoapods-headermap]: Generating header maps.."
+                # 跨组件引用的 public header
+                generate_header_files(sandbox.headers_root, all_targets_headers, Sandbox::POD_TARGETS_HEADERS)
+                # 组件内部使用的 private header
+                project_headers_by_target.each do |target_name, project_headers|
+                    generate_header_files(sandbox.headers_root + "Private/#{target_name}", project_headers, target_name)
+                end
+
+                # return if !is_legacy_target || !Configuration.use_legacy_project_headers
+                generate_header_files(sandbox.headers_root, all_project_headers, Sandbox::POD_PROJECT_HEADERS)
+            end
+
+            # Store headers cache to sandbox.
+            def store_cache_to(path)
+                return unless headers_cache
+                headers_cache.update_headers!(project_headers_by_target, targets_headers_by_target)
+                headers_cache.save_as(path)
+            end
+
+            # Fetch headers cache from sandbox if `incremental_installation` enabled.
+            def analyze_cache_from(path, regenerate_pod_targets)
+                UI.message 'Analyzing Headers Cache' do 
+                    self.headers_cache = HeaderMapsCache.from_file(path)
+                    # Regenerate pod target must remove cache first.
+                    unless regenerate_pod_targets.nil? || regenerate_pod_targets.empty?
+                        regenerate_pod_targets.each do |pod_target|
+                            headers_cache.project_headers_cache.delete(pod_target.pod_name)
+                            headers_cache.targets_headers_cache.delete(pod_target.pod_name)
+                        end
+                    end
+
+                    # Pods that were deleted need to be removed from cache.
+                    unless deleted_pod_targets.empty?
+                        deleted_pod_targets.each do |pod_name|
+                            headers_cache.project_headers_cache.delete(pod_name)
+                            headers_cache.targets_headers_cache.delete(pod_name)
+                        end
+                    end
+
+                    self.project_headers_by_target = headers_cache.project_headers_cache
+                    self.targets_headers_by_target = headers_cache.targets_headers_cache
+
+                    # 将恢复的缓存和当前重新生成的 target 合并
+                    project_headers_by_target.each do |pod_target, project_headers|
+                        all_project_headers.merge!(project_headers) { |key, pre, new| pre } unless project_headers.empty?
+                    end
+                    targets_headers_by_target.each do |pod_target, targets_headers|
+                        all_targets_headers.merge!(targets_headers) unless targets_headers.empty?
+                    end
+                end
+            end
+
+            # Merge the headers for every target and the whole project.
+            # If there is a header file with the same name between different pods, it will keep the previous one.
+            def merge_target_headers(pod_target)
+                pod_project_headers = pod_target.build_headers.pod_project_headers
+                all_project_headers.merge!(pod_project_headers) { |key, pre, new| pre } unless pod_project_headers.empty?
+
+                pod_target_headers = pod_target.build_headers.pod_target_headers
+                all_targets_headers.merge!(pod_target_headers) unless pod_target_headers.empty?
+
+                # Store original data structure of header ordered by target.
+                project_headers_by_target[pod_target.pod_name] = pod_project_headers unless pod_project_headers.empty?
+                targets_headers_by_target[pod_target.pod_name] = pod_target_headers unless pod_target_headers.empty?
+            end
+
+            # Generate `hmap` files for the project of `Pods`.
+            # Pods-all-target-headers.hmap 作为组件 public hmap
+            # Pods-project-headers.hmap 作为不规范 import 组件的兼容 hmap
+            # target_name.hmap 作为组件 private hmap
+            def generate_header_files(dirname, headers, file_name)
+                return if headers.nil? || headers.empty?
+
+                header_json_path = dirname + "#{file_name}.json"
+                File.open(header_json_path, "w") do |f|
+                    f.write(JSON.pretty_generate(headers))
+                end
+                json_to_hmap(header_json_path)
+            end
+
+            # Convert json file to headermap file.
+            def json_to_hmap(json_path)
+                install_brew_package(1) if `which hmap`.empty?
+
+                hmap_path = json_path.sub_ext(".hmap")
+                `hmap convert #{json_path} #{hmap_path}`
+
+                File.delete(json_path) if File.exist?(json_path)
+            end
+
+            # Install swift headermap tool less than three times if neccessary.
+            def install_brew_package(retry_count)
+                raise Informative, "[cocoapods-headermap]: Excuting `brew install milend/taps/hmap` error!" if retry_count > 3
+                if_install_success = system "brew install milend/taps/hmap"
+                install_brew_package(retry_count + 1) unless if_install_success
+            end
+        end
+    end
+
+    # Cache header maps content for `incremental_installation` option
+    class HeaderMapsCache
+        attr_reader :project_headers_cache, :targets_headers_cache
+        
+        def initialize(project_headers_cache = {}, targets_headers_cache = {})
+            @project_headers_cache = project_headers_cache
+            @targets_headers_cache = targets_headers_cache
+        end 
+
+        def self.from_file(path)
+            return HeaderMapsCache.new unless File.exist?(path)
+
+            yaml_content = YAMLHelper.load_file(path)
+            project_headers_cache = yaml_content.fetch("PROJECT_HEADERS", {})
+            targets_headers_cache = yaml_content.fetch("TARGETS_HEADERS", {})
+            new(project_headers_cache, targets_headers_cache)
+        end
+
+        def update_headers!(project_headers_by_target, targets_headers_by_target)
+            @project_headers_cache = project_headers_by_target
+            @targets_headers_cache = targets_headers_by_target
+        end
+
+        def to_hash
+            yaml_content = {}
+            yaml_content["PROJECT_HEADERS"] = project_headers_cache if project_headers_cache
+            yaml_content["TARGETS_HEADERS"] = targets_headers_cache if targets_headers_cache
+            yaml_content
+        end
+
+        def save_as(path)
+            Pathname(path).dirname.mkpath
+            Sandbox.update_changed_file(path, YAMLHelper.convert(to_hash))
+        end
+    end
+end

data/lib/cocoapods-headermap/headers_store.rb

@@ -0,0 +1,128 @@
+require 'fileutils'
+require 'cocoapods-headermap/configuration'
+
+module Pod
+    class Sandbox
+        POD_TARGETS_HEADERS = "Pods-all-target-headers"
+        POD_PROJECT_HEADERS = "Legacy-project-headers"
+
+        class HeadersStore
+            # Implememt the effect of tuples.
+            SYMLINK_REFERENCE = Struct.new(:namespace, :relative_header_path)
+
+            alias_method :new_add_files, :add_files
+            alias_method :new_search_paths, :search_paths
+
+            # 保存当前 target name
+            attr_reader :target_name
+            def target_name=(target_name)
+                @target_name = target_name
+            end
+
+            # @return [Hash{Pathname => Hash{String, String}}] public headers 映射
+            def pod_target_headers
+                @pod_target_headers ||= {}
+            end
+
+            # @return [Hash{Pathname => Hash{String, String}}] private headers 映射
+            def pod_project_headers
+                @pod_project_headers ||= {}
+            end
+
+            # @return [Array<Pathname>] Generate every part of namespace recusively.
+            # Passing ["WCDB", "include", "source"] return the following content:
+            #
+            # ["WCDB/include/source", "include/source", "source"]
+            def purge_shared_keys(parts, index)
+                return [] if index == parts.length
+                res = [parts.slice(index, parts.length - index).reduce(Pathname.new(""), :+)]
+                res.concat(purge_shared_keys(parts, index + 1))
+                res
+            end
+             
+            def add_files(namespace, relative_header_paths) 
+                root.join(namespace).mkpath unless relative_header_paths.empty?
+
+                new_add_files(namespace, relative_header_paths)
+                return if @visibility_scope == :public
+                
+                list = namespace.each_filename.to_a
+                parts = purge_shared_keys(list, 0)
+                relative_header_paths.map do |relative_header_path|
+                    add_targets_headers(parts, namespace, relative_header_path)
+                    add_project_headers(relative_header_path)
+                end
+            end
+
+            # 保存带命名空间的 headers 与其 symlink 路径的映射
+            # 结构如下：
+            #    {"AFNetworking/AFNetworking.h" => "$PODS_ROOT/Headers/Public/AFNetworking/AFNetworking.h"}
+            #
+            # 用于生成 public hmap，并写入 `HEADER_SEARCH_PATH`，可使用 <Pod/header.h>、"Pod/head.h" 引用
+            # 如果 `namespace/header` 字典序更大，将覆盖之前的 path 值
+            def add_targets_headers(parts, namespace, relative_header_path)
+
+                # public header，使用头文件 symlink 路径
+                header_source = root + namespace + relative_header_path.basename
+                header_section = {
+                    "prefix" => "#{header_source.dirname.to_s}/",
+                    "suffix" => header_source.basename.to_s
+                }
+
+                parts.each do |part|
+                    key = "#{part}/#{header_source.basename}"
+                    next if pod_target_headers.key?(key) && (pod_target_headers[key]["prefix"] <=> "#{header_source.dirname.to_s}/") == 1
+                    pod_target_headers[key] = header_section
+                end
+            end
+
+            # 保存不带命名空间的 header 与其原始路径的映射
+            # 结构如下:
+            #
+            #    {"AFNetworking" => "$PODS_ROOT/AFNetworking/AFNetworking.h"}
+            #
+            # 用于生成 private hmap，并写入 `HEADER_SEARCH_PATH`，在组件内部 *.{m,c,cpp} 使用 <header.h>、"head.h" 引用
+            # 可选生成跨组件的 shared hmap，写入 `USER_HEADER_SEARCH_PATH`，规避不规范 un-namespaced 引用
+            def add_project_headers(relative_header_path)
+
+                # private header，使用头文件原始路径
+                header_source = sandbox.root + relative_header_path
+
+                source_file_name = header_source.basename.to_s
+                header_section = {
+                    "prefix" => "#{header_source.dirname.to_s}/",
+                    "suffix" => source_file_name.to_s
+                }
+
+                return if pod_project_headers.key?(source_file_name) && (pod_project_headers[source_file_name]["prefix"] <=> "#{header_source.dirname.to_s}/") == 1
+                pod_project_headers[source_file_name] = header_section
+            end
+
+            # @return [Array<String>] Public hmap + Private hmap
+            def search_paths(platform, target_name = nil, use_modular_headers = false)
+                visibility_dir = root.relative_path_from(sandbox.root)
+                headers_dir = visibility_dir.dirname
+                
+                paths = []
+                paths << "${PODS_ROOT}/#{visibility_dir}/#{@target_name}/#{@target_name}.hmap" if @visibility_scope == :private
+                paths << "${PODS_ROOT}/#{headers_dir}/#{Sandbox::POD_TARGETS_HEADERS}.hmap"
+                
+                # 保留 CocoaPods 自动写入的 symlink 路径
+                if Configuration.keep_symlink_headers
+                    paths.concat(new_search_paths(platform, target_name, use_modular_headers))
+                else
+                    if Configuration.always_keep_symlink_headers.include?(target_name)
+                        paths.concat(new_search_paths(platform, target_name, use_modular_headers))
+                    end
+                end
+                paths
+            end
+
+            # Clean `$PODS_ROOT/Headers` directory.
+            def rm_headers_root!
+                return if @visibility_scope == :private
+                FileUtils.rm_rf(Dir.glob(sandbox.headers_root + "**" + "*.hmap"))
+            end
+        end
+    end
+end

data/lib/cocoapods-headermap/installer.rb

@@ -0,0 +1,31 @@
+require 'cocoapods-headermap/configuration'
+
+module Pod
+    class Installer
+        alias_method :new_run_podfile_post_install_hooks, :run_podfile_post_install_hooks
+        alias_method :new_clean_sandbox, :clean_sandbox
+
+        def run_podfile_post_install_hooks
+            # 开启 Multi Pods Project 选项
+            if podfile.installation_options.generate_multiple_pod_projects
+                @pod_target_subprojects.flat_map { |project| project.targets }.each do |target|
+                    target.build_configurations.each do |config|
+                        config.build_settings['USE_HEADERMAP'] = 'NO'
+                    end
+                end
+            else
+                @pods_project.targets.each do |target|
+                    target.build_configurations.each do |config|
+                        config.build_settings['USE_HEADERMAP'] = 'NO'
+                    end
+                end
+            end
+            new_run_podfile_post_install_hooks
+        end
+
+        def clean_sandbox(pod_targets)
+            new_clean_sandbox(pod_targets)
+            sandbox.public_headers.rm_headers_root!
+        end
+    end
+end

data/lib/cocoapods-headermap/multi_pods_project_generator.rb

@@ -0,0 +1,46 @@
+require 'cocoapods-headermap/header_maps_generator'
+
+module Pod
+    class Installer
+        class Xcode
+            class MultiPodsProjectGenerator < PodsProjectGenerator
+                def generate!
+                    # Generate container Pods.xcodeproj.
+                    container_project = create_container_project(aggregate_targets, sandbox.project_path)
+
+                    project_paths_by_pod_targets = pod_targets.group_by do |pod_target|
+                        sandbox.pod_target_project_path(pod_target.project_name)
+                    end
+
+                    # If `incremental_installation` enabled, read cache from sanbox.
+                    if installation_options.incremental_installation
+                        HeaderMapsGenerator.analyze_cache_from(project_headers_cache_path, pod_targets)
+                    end
+
+                    projects_by_pod_targets = Hash[project_paths_by_pod_targets.map do |project_path, pod_targets|
+                        project = create_pods_project(pod_targets, project_path, container_project)
+                        [project, pod_targets]
+                    end]
+
+                    # Generate header map files and cache if neccessary.
+                    HeaderMapsGenerator.generate!(sandbox, false)
+                    HeaderMapsGenerator.store_cache_to(project_headers_cache_path)
+
+                    # Note: We must call `install_file_references` on all pod targets before installing them.
+                    pod_target_installation_results = install_all_pod_targets(projects_by_pod_targets)
+                    aggregate_target_installation_results = install_aggregate_targets_into_project(container_project, aggregate_targets)
+                    target_installation_results = InstallationResults.new(pod_target_installation_results, aggregate_target_installation_results)
+
+                    integrate_targets(target_installation_results.pod_target_installation_results)
+                    wire_target_dependencies(target_installation_results)
+                    PodsProjectGeneratorResult.new(container_project, projects_by_pod_targets, target_installation_results)
+                end
+
+                # Project headers cache path.
+                def project_headers_cache_path
+                    sandbox.root.join('.project_cache', 'project_headers_cache.yaml')
+                end
+            end
+        end
+    end
+end

data/lib/cocoapods-headermap/pod_target.rb

@@ -0,0 +1,24 @@
+module Pod
+    class PodTarget < Target
+        alias_method :new_header_search_paths, :header_search_paths
+
+        # Move the mapping files to the top of the array by sorting.
+        #
+        # Before sort:
+        # ["${PODS_ROOT}/Headers/Private/AFNetworking.hmap",
+        #  "${PODS_ROOT}/Headers/Private/AFNetworking",
+        #  "${PODS_ROOT}/Headers/Public/Public-Header-Maps.hmap",
+        #  "${PODS_ROOT}/Headers/Public/AFNetworking"]
+        #
+        # After sort:
+        # ["${PODS_ROOT}/Headers/Private/AFNetworking.hmap", 
+        #  "${PODS_ROOT}/Headers/Public/Public-Header-Maps.hmap", 
+        #  "${PODS_ROOT}/Headers/Private/AFNetworking", 
+        #  "${PODS_ROOT}/Headers/Public/AFNetworking"]
+        def header_search_paths(include_dependent_targets_for_test_spec: nil, include_dependent_targets_for_app_spec: nil, include_private_headers: true, configuration: nil)
+            paths = new_header_search_paths(:include_dependent_targets_for_test_spec => include_dependent_targets_for_test_spec, :include_dependent_targets_for_app_spec => include_dependent_targets_for_app_spec, :include_private_headers => include_private_headers, :configuration => configuration)
+            paths.sort_by { |i| i.split(".").last == "hmap" ? 0 : 1 }
+            paths
+        end
+    end
+end

data/lib/cocoapods-headermap/sandbox.rb

@@ -0,0 +1,12 @@
+require 'cocoapods-headermap/header_maps_generator'
+
+module Pod
+    class Sandbox
+        alias_method :new_clean_pod, :clean_pod
+
+        def clean_pod(name)
+            new_clean_pod(name)
+            HeaderMapsGenerator.deleted_pod_targets = name
+        end
+    end
+end

data/lib/cocoapods-headermap/single_pods_project_generator.rb

@@ -0,0 +1,29 @@
+require 'cocoapods-headermap/header_maps_generator'
+
+module Pod
+    class Installer
+        class Xcode
+            class SinglePodsProjectGenerator < PodsProjectGenerator
+                def generate!
+                    project_path = sandbox.project_path
+                    platforms = aggregate_targets.map(&:platform)
+                    project_generator = ProjectGenerator.new(sandbox, project_path, pod_targets, build_configurations,
+                                                             platforms, project_object_version, config.podfile_path)
+                    project = project_generator.generate!
+                    install_file_references(project, pod_targets)
+
+                    # Generate header map files.
+                    HeaderMapsGenerator.generate!(sandbox, true)
+          
+                    pod_target_installation_results = install_all_pod_targets(project, pod_targets)
+                    aggregate_target_installation_results = install_aggregate_targets(project, aggregate_targets)
+                    target_installation_results = InstallationResults.new(pod_target_installation_results, aggregate_target_installation_results)
+          
+                    integrate_targets(target_installation_results.pod_target_installation_results)
+                    wire_target_dependencies(target_installation_results)
+                    PodsProjectGeneratorResult.new(project, {}, target_installation_results)
+                  end
+            end
+        end
+    end
+end

data/lib/cocoapods-headermap.rb

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

data/lib/cocoapods_plugin.rb

@@ -0,0 +1,24 @@
+# require 'cocoapods-headermap/command'
+
+module CocoapodsHmapGod
+    Pod::HooksManager.register("cocoapods-headermap", :pre_install) do |context, options|
+        
+        require 'cocoapods-headermap/build_settings'
+        require 'cocoapods-headermap/configuration'
+        require 'cocoapods-headermap/file_references_installer'
+        require 'cocoapods-headermap/headers_store'
+        require 'cocoapods-headermap/installer'
+        require 'cocoapods-headermap/multi_pods_project_generator'
+        require 'cocoapods-headermap/pod_target'
+        require 'cocoapods-headermap/sandbox'
+        require 'cocoapods-headermap/single_pods_project_generator'
+        
+        Pod::Configuration.keep_symlink_headers = options[:keep_symlink_headers] if options.key?(:keep_symlink_headers)
+        Pod::Configuration.always_keep_symlink_headers = options[:always_keep_symlink_headers] if options.key?(:always_keep_symlink_headers)
+    end
+
+    Pod::HooksManager.register("cocoapods-hmap-god", :post_install) do |context|
+        # Hook `run_podfile_post_install_hooks` to change build settings rather than `:post_install`.
+        # The time to perform `:post_install` is right after the pod project is generated.
+    end
+end

data/spec/command/headermap_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+module Pod
+  describe Command::Headermap do
+    describe 'CLAide' do
+      it 'registers it self' do
+        Command.parse(%w{ headermap }).should.be.instance_of Command::Headermap
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+require 'pathname'
+ROOT = Pathname.new(File.expand_path('../../', __FILE__))
+$:.unshift((ROOT + 'lib').to_s)
+$:.unshift((ROOT + 'spec').to_s)
+
+require 'bundler/setup'
+require 'bacon'
+require 'mocha-on-bacon'
+require 'pretty_bacon'
+require 'pathname'
+require 'cocoapods'
+
+Mocha::Configuration.prevent(:stubbing_non_existent_method)
+
+require 'cocoapods_plugin'
+
+#-----------------------------------------------------------------------------#
+
+module Pod
+
+  # Disable the wrapping so the output is deterministic in the tests.
+  #
+  UI.disable_wrap = true
+
+  # Redirects the messages to an internal store.
+  #
+  module UI
+    @output = ''
+    @warnings = ''
+
+    class << self
+      attr_accessor :output
+      attr_accessor :warnings
+
+      def puts(message = '')
+        @output << "#{message}\n"
+      end
+
+      def warn(message = '', actions = [])
+        @warnings << "#{message}\n"
+      end
+
+      def print(message)
+        @output << message
+      end
+    end
+  end
+end
+
+#-----------------------------------------------------------------------------#

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: cocoapods-headermap
+version: !ruby/object:Gem::Version
+  version: 1.0.7
+platform: ruby
+authors:
+- menttofly
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-11-16 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: Improve Xcode compilation speed based on Header Maps.
+email:
+- 1028365614@qq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cocoapods-headermap.gemspec
+- lib/cocoapods-headermap.rb
+- lib/cocoapods-headermap/build_settings.rb
+- lib/cocoapods-headermap/command.rb
+- lib/cocoapods-headermap/command/headermap.rb
+- lib/cocoapods-headermap/configuration.rb
+- lib/cocoapods-headermap/file_references_installer.rb
+- lib/cocoapods-headermap/gem_version.rb
+- lib/cocoapods-headermap/header_maps_generator.rb
+- lib/cocoapods-headermap/headers_store.rb
+- lib/cocoapods-headermap/installer.rb
+- lib/cocoapods-headermap/multi_pods_project_generator.rb
+- lib/cocoapods-headermap/pod_target.rb
+- lib/cocoapods-headermap/sandbox.rb
+- lib/cocoapods-headermap/single_pods_project_generator.rb
+- lib/cocoapods_plugin.rb
+- spec/command/headermap_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Generate header maps file instead of creating soft link during pod installation.
+  Therefore, file IO can be reduced during the build process and the search speed
+  of header files can be improved.
+test_files:
+- spec/command/headermap_spec.rb
+- spec/spec_helper.rb