cocoapods-hmap-prebuilt 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 06ec400c0386357e5211eebf6b5a14f9698e652c2f02349d393652b079528f35
+  data.tar.gz: 1e8b99f1e32e4086a24300566d0bcadb7b5395dfc19d58bf516878c80f50d68b
+SHA512:
+  metadata.gz: 4bd94eb184b1f0c5d0fe2234001bdea13f38a31c3acea71d98b9a70e01cdf737fddc2f47118e42092846c84ffabdc3c03125576eb521e499e40fadd6ae164f83
+  data.tar.gz: 96017f250188e500d55cb8258885db82fd779b26643fafbb039c7592a7635275040bc99c3149deb54fae7f633df4f5b791cfd48f8c35540786a9ddba2bd4ce52

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2021 EricLou <499304609@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,40 @@
+# cocoapods-hmap-prebuilt
+
+A description of cocoapods-hmap-prebuilt.
+
+## Installation
+
+    $ gem install cocoapods-hmap-prebuilt
+
+## Usage
+
+The command should be executed in directory that contains podfile.
+
+```shell
+# write the hmap file to podfile/Pods/Headers/HMap
+$ pod hmap-writer
+
+# write the hmap file to /project/dir/Pods/Headers/HMap
+$ pod hmap-writer --project-directory=/project/dir/
+
+# write the hmap file to /project/dir/Pods/Headers/HMap and no save origin [HEADER_SEARCH_PATHS]
+$ pod hmap-writer --project-directory=/project/dir/ --nosave-origin-header-search-paths
+
+# cleanup the hmap file
+$ pod hmap-writer --clean-hmap
+
+# read the hmap file from /hmap/dir/file
+$ pod hmap-reader --hmap-path=/hmap/dir/file
+```
+
+At same time, you can put this line in your podfile:
+
+```rb
+plugin 'cocoapods-hmap-prebuilt'
+```
+
+## Command Line Tool
+
+Installing the 'cocoapods-hmap-prebuilt' gem will also install two command-line tool `hmap-prebuilt-read` and `hmap-prebuilt-write` which you can use to generate header map file and read hmap file.
+
+For more information consult `hmap-prebuilt-read --help` or `hmap-prebuilt-write --help`.

data/bin/hmap-prebuilt-read

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+if $PROGRAM_NAME == __FILE__
+  ENV['BUNDLE_GEMFILE'] = File.expand_path('../Gemfile', __dir__)
+  require 'bundler/setup'
+end
+
+require 'cocoapods-hmap-prebuilt/command/hmap_reader'
+
+Pod::Command::HMapReader.run(ARGV)

data/bin/hmap-prebuilt-write

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+if $PROGRAM_NAME == __FILE__
+  ENV['BUNDLE_GEMFILE'] = File.expand_path('../Gemfile', __dir__)
+  require 'bundler/setup'
+end
+
+require 'cocoapods-hmap-prebuilt/command/hmap_writer'
+
+Pod::Command::HMapWriter.run(ARGV)

data/lib/cocoapods-hmap-prebuilt.rb

@@ -0,0 +1,13 @@
+# The primary namespace for cocoapods-hmap-prebuilt.
+module HMap
+    require_relative 'cocoapods-hmap-prebuilt/hmap_version'
+    require_relative 'cocoapods-hmap-prebuilt/hmap_view'
+    require_relative 'cocoapods-hmap-prebuilt/hmap_struct'
+    require_relative 'cocoapods-hmap-prebuilt/hmap_utils'
+    require_relative 'cocoapods-hmap-prebuilt/hmap_helper'
+    require_relative 'cocoapods-hmap-prebuilt/hmap_exceptions'
+  
+    autoload :HMapFileReader, 'cocoapods-hmap-prebuilt/hmap_file_reader'
+    autoload :HMapFileWriter, 'cocoapods-hmap-prebuilt/hmap_file_writer'
+    autoload :HMapFile, 'cocoapods-hmap-prebuilt/hmap_file'
+end

data/lib/cocoapods-hmap-prebuilt/command/hmap_reader.rb

@@ -0,0 +1,39 @@
+require 'cocoapods-hmap-prebuilt'
+require 'cocoapods'
+
+module Pod
+  class Command
+    class HMapReader < Command
+      self.summary = 'Read mapfile and puts result.'
+
+      self.description = <<-DESC
+      Read mapfile and puts result, header, buckets, string_table.
+      DESC
+
+      def initialize(argv)
+        super
+        hmap_file_path = argv.option('hmap-path')
+        @hmap_file_path = Pathname.new(hmap_file_path).expand_path unless hmap_file_path.nil?
+      end
+
+      def validate!
+        super
+        banner! if help?
+        raise '[ERROR]: --hmap-path no set'.red unless File.exist?(@hmap_file_path)
+      end
+
+      def self.options
+        [
+          ['--hmap-path=/hmap/dir/file', 'The path of the hmap file']
+        ].concat(super)
+      end
+
+      def run
+        UI.section "\n[hmap-reader] start..............\n".yellow do
+          HMap::MapFileReader.new(@hmap_file_path)
+        end
+        UI.puts("\n[hmap-reader] finish..............\n".yellow)
+      end
+    end
+  end
+end

data/lib/cocoapods-hmap-prebuilt/command/hmap_writer.rb

@@ -0,0 +1,46 @@
+require 'cocoapods-hmap-prebuilt'
+require 'cocoapods'
+
+module Pod
+  class Command
+    class HMapWriter < Command
+      self.summary = 'Analyzes the dependencies and gen each dependencie mapfile.'
+
+      self.description = <<-DESC
+      Analyzes the dependencies of any cocoapods projects and gen each dependencie mapfile.
+      DESC
+
+      def initialize(argv)
+        super
+        project_directory = argv.option('project-directory')
+        @save_origin_header_search_paths = !argv.flag?('nosave-origin-header-search-paths', false)
+        @clean_hmap = argv.flag?('clean-hmap', false)
+
+        return if project_directory.nil?
+
+        @project_directory = Pathname.new(project_directory).expand_path
+        config.installation_root = @project_directory
+      end
+
+      def validate!
+        super
+        verify_podfile_exists!
+      end
+
+      def self.options
+        [
+          ['--project-directory=/project/dir/', 'The path to the root of the project directory'],
+          ['--nosave-origin-header-search-paths', 'This option will not save xcconfig origin [HEADER_SEARCH_PATHS] and put hmap file first'],
+          ['--clean-hmap', 'This option will clean up all hmap-prebuilt setup for hmap.']
+        ].concat(super)
+      end
+
+      def run
+        UI.section "\n[hmap-prebuilt] start.............." do
+          HMap::HMapFileWriter.new(@save_origin_header_search_paths, @clean_hmap)
+        end
+        UI.puts('[hmap-prebuilt] finish..............')
+      end
+    end
+  end
+end

data/lib/cocoapods-hmap-prebuilt/hmap_file_reader.rb

@@ -0,0 +1,91 @@
+module HMap
+
+  class HMapFileReader
+    # @return [String, nil] the filename loaded from, or nil if loaded from a binary
+    #  string
+    attr_reader :filename
+    # # @return [Hash] any parser options that the instance was created with
+    # attr_reader :options
+
+    # @return true/false the swapped of the mapfile
+    attr_reader :swapped
+
+    # @return [HMap::HMapHeader]
+    attr_reader :header
+
+    # @return [Hash<HMap::HMapBucket => HMap::HMapBucketStr>] an array of the file's bucktes
+    # @note bucktes are provided in order of ascending offset.
+    attr_reader :bucktes
+
+    def initialize(path)
+      raise ArgumentError, "#{path}: no such file" unless File.file?(path)
+
+      @filename = path
+      @raw_data = File.open(@filename, 'rb', &:read)
+      populate_fields
+      puts description
+    end
+
+    # Populate the instance's fields with the raw HMap data.
+    # @return [void]
+    # @note This method is public, but should (almost) never need to be called.
+    def populate_fields
+      @header = populate_hmap_header
+      string_t = @raw_data[header.strings_offset..-1]
+      @bucktes = populate_buckets do |bucket|
+        bucket_s = bucket.to_a.map do |key|
+          string_t[key..-1].match(/[^\0]+/)[0]
+        end
+        HMapBucketStr.new(*bucket_s)
+      end
+    end
+
+    # The file's HMapheader structure.
+    # @return [HMap::HMapHeader]
+    # @raise [TruncatedFileError] if the file is too small to have a valid header
+    # @api private
+    def populate_hmap_header
+      raise TruncatedFileError if @raw_data.size < HMapHeader.bytesize + 8 * HMapBucket.bytesize
+
+      populate_and_check_magic
+      HMapHeader.new_from_bin(swapped, @raw_data[0, HMapHeader.bytesize])
+    end
+
+    # Read just the file's magic number and check its validity.
+    # @return [Integer] the magic
+    # @raise [MagicError] if the magic is not valid HMap magic
+    # @api private
+    def populate_and_check_magic
+      magic = @raw_data[0..3].unpack1('N')
+      raise MagicError, magic unless Utils.magic?(magic)
+
+      version = @raw_data[4..5].unpack1('n')
+      @swapped = Utils.swapped_magic?(magic, version)
+    end
+
+    # All buckets in the file.
+    # @return [Array<HMap::HMapBucket>]  an array of buckets
+    # @api private
+    def populate_buckets
+      bucket_offset = header.class.bytesize
+      bucktes = []
+      header.num_buckets.times do |i|
+        bucket = HMapBucket.new_from_bin(swapped, @raw_data[bucket_offset, HMapBucket.bytesize])
+        bucket_offset += HMapBucket.bytesize
+        next if bucket.key == HEADER_CONST[:HMAP_EMPTY_BUCKT_KEY]
+
+        bucktes[i] = { bucket => yield(bucket) }
+      end
+      bucktes
+    end
+
+    def description
+      sum = "  Header map: #{filename}\n" + header.description
+      bucktes.each_with_index do |buckte_h, index|
+        sum += "\t- Bucket: #{index}" + Utils.safe_encode(buckte_h.values[0].description, 'UTF-8') unless buckte_h.nil?
+        sum
+      end
+      sum
+    end
+  end
+end

data/lib/cocoapods-hmap-prebuilt/hmap_file_writer.rb

@@ -0,0 +1,148 @@
+require 'cocoapods'
+
+module HMap
+
+  HMAP_DIR_NAME = 'HMap'
+
+  # mapfile type
+  # @note public => pods public,
+  # private => pods private,
+  # all => public + private + extra.
+  # @api private
+  HMMAP_TYPE = {
+    public_header_files: 'public',
+    private_header_files: 'private',
+    all_files: 'all' 
+  }.freeze
+
+  HEAD_SEARCH_PATHS = 'HEADER_SEARCH_PATHS'
+
+  # Helper module which returns handle method from HMapFileWriter.
+  class HMapFileWriter
+    def initialize(save_origin_header_search_paths, clean_hmap)
+      config = Pod::Config.instance
+      analyze = Helper::PodHelper.pod_analyze(config)
+      hmap_dir = hmap_dir(config)
+      targets = analyze.targets
+      pod_targets = analyze.pod_targets
+      clean_hmap(clean_hmap, hmap_dir, targets, pod_targets)
+      return if clean_hmap
+
+      @save_origin_header_search_paths = save_origin_header_search_paths
+      gen_hmapfile(targets, pod_targets, hmap_dir)
+    end
+
+    private
+
+    def hmap_dir(config)
+      hmap_dir = File.join(config.sandbox.headers_root, HMAP_DIR_NAME)
+      puts "HMap dir: #{hmap_dir}"
+      hmap_dir
+    end
+
+    def clean_hmap(clean_hmap, hmap_dir, *targets)
+      return unless clean_hmap
+      FileUtils.rm_rf(hmap_dir)
+      targets.each do |tg|
+        Utils.clean_target_build_setting(tg, HEAD_SEARCH_PATHS)
+      end
+    end
+
+    def gen_hmapfile(targets, pod_targets, hmap_dir)
+      puts('Inspecting targets to integrate ')
+      merge_all_pods_target_headers_mapfile(pod_targets, hmap_dir)
+      merge_all_target_public_mapfile(targets, hmap_dir)
+      create_each_target_mapfile(pod_targets, hmap_dir)
+    end
+
+    def header_perfix(file, keys)
+      perfix = "#{file.dirname}/"
+      suffix = file.basename.to_s
+      keys.inject([]) do |sum, name|
+        sum << [name.to_s, perfix, suffix]
+      end
+    end
+
+    def header_to_hash(keys, headers, index, buckets)
+      index = index.length
+      keys.inject('') do |sum, bucket|
+        buckte = HMapBucketStr.new(*bucket)
+        string_t = buckte.bucket_to_string(headers, index + sum.length)
+        buckets.push(buckte)
+        sum + string_t
+      end
+    end
+
+    def merge_all_target_public_mapfile(targets, hmap_dir)
+      method = method(:from_header_mappings_by_file_accessor)
+      targets.each do |target|
+        hmap_file_name = "#{target.name}-All-Public-Headers.hmap"
+        single_target_mapfile(target.pod_targets, hmap_dir, hmap_file_name, method)
+        change_target_xcconfig_header_search_path([hmap_file_name], true, target)
+      end
+    end
+
+    def merge_all_pods_target_headers_mapfile(pod_targets, hmap_dir)
+      method = method(:from_header_mappings_by_file_accessor)
+      hmap_file_name = 'All-Pods-Headers.hmap'
+      single_target_mapfile(pod_targets, hmap_dir, hmap_file_name, method, :all_files)
+      change_target_xcconfig_header_search_path([hmap_file_name], false, *pod_targets)
+    end
+
+    def create_each_target_mapfile(pod_targets, hmap_dir)
+      pod_targets.each do |target|
+        HMMAP_TYPE.flat_map do |key, value|
+          hmap_file_name = "#{target.name}-#{value}-hmap.hmap"
+          method = method(:from_header_mappings_by_file_accessor)
+          single_target_mapfile([target], File.join(hmap_dir, target.name), hmap_file_name, method, key)
+          "#{target.name}/#{hmap_file_name}" if key == :all_files
+        end.compact
+      end
+    end
+
+    def from_header_mappings_by_file_accessor(header_h, buckets, target, hmap_type)
+        hmap_t = hmap_type == :all_files ? 'headers' : "#{HMMAP_TYPE[hmap_type]}_headers"
+        valid_accessors = target.file_accessors.reject { |fa| fa.spec.non_library_specification? }
+        headers = valid_accessors.each_with_object({}) do |file_accessor, sum|
+          # Private headers will always end up in Pods/Headers/Private/PodA/*.h
+          # This will allow for `""` imports to work.
+          type_header = file_accessor.method(hmap_t.to_sym).call
+          Helper::PodHelper.header_mappings(file_accessor, type_header, target).each do |key, value|
+            sum[key] ||= []
+            sum[key] += value
+          end
+        end
+  
+        if target.build_as_framework?
+          headers[target.prefix_header_path] = [target.prefix_header_path.basename]
+          headers[target.umbrella_header_path] = [target.umbrella_header_path.basename]
+        end
+        headers.each_with_object(buckets) do |header_f, sum|
+          keys = header_perfix(*header_f)
+          sum[0] += header_to_hash(keys, header_h, *sum)
+        end
+    end
+
+    def single_target_mapfile(pod_targets, hmap_dir, hmap_file_name, headers, hmap_type = :public_header_files)
+      hmap_file_path = Pathname(File.join(hmap_dir, hmap_file_name))
+      header_h = {}
+      buckets = pod_targets.inject(["\0", []]) do |bucktes, target|
+        headers.call(header_h, bucktes, target, hmap_type)
+      end
+      wirte_mapfile_to_path(hmap_file_path, buckets)
+    end
+
+    def wirte_mapfile_to_path(hmap_file_path, buckets)
+      print "\t - save hmap file to path:"
+      puts hmap_file_path.to_s.yellow
+      HMapFile.new(*buckets).write(hmap_file_path)
+    end
+
+    def change_target_xcconfig_header_search_path(hmap_h, use_headermap, *targets)
+      Utils.target_xcconfig_path(targets) do |xc|
+        Utils.change_xcconfig_header_search_path(xc, hmap_h, use_headermap: use_headermap,
+                                                            save_origin: @save_origin_header_search_paths)
+      end
+    end
+  end
+end

data/lib/cocoapods-hmap-prebuilt/hmap_helper.rb

@@ -0,0 +1,85 @@
+
+require 'cocoapods'
+
+module HMap
+  # A collection of Helper functions used throughout cocoapods-hmap-prebuilt.
+  module Helper
+    # A collection of PodHelper functions used throughout cocoapods-hmap-prebuilt.
+    module PodHelper
+      HEADER_EXTENSIONS = Pod::Sandbox::FileAccessor::HEADER_EXTENSIONS
+      
+      def self.pod_analyze(config)
+        podfile = Pod::Podfile.from_file(config.podfile_path)
+        lockfile = Pod::Lockfile.from_file(config.lockfile_path)
+        Pod::Installer::Analyzer.new(config.sandbox, podfile, lockfile).analyze
+      end
+
+      # @!group Private helpers
+
+      # Returns the list of the paths founds in the file system for the
+      # attribute with given name. It takes into account any dir pattern and
+      # any file excluded in the specification.
+      #
+      # @param  [Symbol] attribute
+      #         the name of the attribute.
+      #
+      # @return [Array<Pathname>] the paths.
+      #
+      def self.paths_for_attribute(key, attribute, include_dirs: false)
+        file_patterns = key.spec_consumer.send(attribute)
+        options = {
+          exclude_patterns: key.spec_consumer.exclude_files,
+          dir_pattern: Pod::Sandbox::FileAccessor::GLOB_PATTERNS[attribute],
+          include_dirs: include_dirs
+        }
+        extensions = HEADER_EXTENSIONS
+        key.path_list.relative_glob(file_patterns, options).map do |f|
+          [f, key.path_list.root.join(f)] if extensions.include?(f.extname)
+        end.compact
+      end
+
+      def self.header_mappings(file_accessor, headers, target)
+        consumer = file_accessor.spec_consumer
+        header_mappings_dir = consumer.header_mappings_dir
+        dir = target.headers_sandbox
+        dir_h = Pathname.new(target.product_module_name)
+        dir += consumer.header_dir if consumer.header_dir
+        mappings = {}
+        headers.each do |header|
+          next if header.to_s.include?('.framework/')
+
+          sub_dir = [dir, dir_h]
+          if header_mappings_dir
+            relative_path = header.relative_path_from(file_accessor.path_list.root + header_mappings_dir)
+            sub_dir << dir + relative_path.dirname
+            sub_dir << dir_h + relative_path.dirname
+          else
+            relative_path = header.relative_path_from(file_accessor.path_list.root)
+            sub_dir << relative_path.dirname
+          end
+          mappings[header] ||= []
+          sub_dir.uniq.each do |d|
+            mappings[header] << d + header.basename
+          end
+          mappings[header] << header.basename
+        end
+        mappings
+      end
+
+      def self.pod_target_source_header(target, hmap_t)
+        target.header_mappings_by_file_accessor.keys.flat_map do |key|
+          paths_for_attribute(key, hmap_t)
+        end
+      end
+
+      def self.pod_target_source_header_map(target, hmap_t)
+        pod_target_source_header(target, hmap_t).each_with_object({}) do |f, sum|
+          file = f[1]
+          key = f[0].to_s
+          r_key = file.basename.to_s
+          sum[r_key] = [key, r_key].uniq
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-hmap-prebuilt/hmap_struct.rb

@@ -0,0 +1,264 @@
+
+module HMap
+    HEADER_CONST = {
+      HMAP_HEADER_MAGIC_NUMBER: 0x686d6170,
+      HMAP_HEADER_VERSION: 0x0001,
+      HMAP_EMPTY_BUCKT_KEY: 0,
+      HMAP_SWAPPED_MAGIC: 0x70616d68,
+      HMAP_SWAPPED_VERSION: 0x0100
+    }.freeze
+  
+    # A general purpose pseudo-structure.
+    # @abstract
+    class HMapStructure
+      # The String#unpack format of the data structure.
+      # @return [String] the unpacking format
+      # @api private
+      FORMAT = ''
+  
+      # The size of the data structure, in bytes.
+      # @return [Integer] the size, in bytes
+      # @api private
+      SIZEOF = 0
+  
+      SWAPPED = true
+  
+      # @return [Integer] the size, in bytes, of the represented structure.
+      def self.bytesize
+        self::SIZEOF
+      end
+  
+      def self.format
+        self::FORMAT
+      end
+  
+      def self.swapped?
+        self::SWAPPED
+      end
+  
+      # @param swapped [Bool] the swapped of the mapfile
+      # @param bin [String] the string to be unpacked into the new structure
+      # @return [HMap::HMapStructure] the resulting structure
+      # @api private
+      def self.new_from_bin(swapped, bin)
+        format = Utils.specialize_format(self::FORMAT, swapped)
+        new(*bin.unpack(format))
+      end
+  
+      def serialize
+        [].pack(format)
+      end
+  
+      # @return [Hash] a hash representation of this {HMapStructure}.
+      def to_h
+        {
+          'structure' => {
+            'format' => self.class::FORMAT,
+            'bytesize' => self.class.bytesize
+          }
+        }
+      end
+    end
+  
+    # HMapHeader structure.
+    # @see https://clang.llvm.org/doxygen/structclang_1_1HMapHeader.html
+    # @abstract
+    class HMapHeader < HMapStructure
+      # @return [HMap::HMapView, nil] the raw view associated with the load command,
+      # or nil if the HMapHeader was created via {create}.
+      attr_reader :num_entries, :magic, :version, :reserved, :strings_offset, :num_buckets, :max_value_length
+  
+      FORMAT = 'L=1S=2L4'
+      # @see HMapStructure::SIZEOF
+      # @api private
+      SIZEOF = 24
+  
+      # @api private
+      def initialize(magic, version, reserved, strings_offset, num_entries, num_buckets, max_value_length)
+        @magic = magic
+        @version = version
+        @reserved = reserved
+        @strings_offset = strings_offset
+        @num_entries = num_entries
+        @num_buckets = num_buckets
+        @max_value_length = max_value_length
+        super()
+      end
+  
+      # @return [String] the serialized fields of the mafile
+      def serialize
+        format = Utils.specialize_format(FORMAT, SWAPPED)
+        [magic, version, reserved, strings_offset, num_entries, num_buckets, max_value_length].pack(format)
+      end
+  
+      def description
+        <<-DESC
+          Hash bucket count: #{@num_buckets}
+          String table entry count: #{@num_entries}
+          Max value length: #{@max_value_length}
+        DESC
+      end
+  
+      def to_h
+        {
+          'magic' => magic,
+          'version' => version,
+          'reserved' => reserved,
+          'strings_offset' => strings_offset,
+          'num_entries' => num_entries,
+          'num_buckets' => num_buckets,
+          'max_value_length' => max_value_length
+        }.merge super
+      end
+    end
+  
+    # HMapBucketStr => HMapBucket.
+    # @see https://clang.llvm.org/doxygen/structclang_1_1HMapHeader.html
+    # @abstract
+    class HMapBucketStr
+      attr_reader :uuid, :key, :perfix, :suffix
+  
+      def initialize(key, perfix, suffix)
+        @uuid = Utils.string_downcase_hash(key)
+        @key = key
+        @perfix = perfix
+        @suffix = suffix
+        @str_ins = {}
+      end
+  
+      def bucket_to_string(headers, index)
+        bucket = [key, perfix, suffix]
+        bucket.inject('') do |sum, arg|
+          if headers[arg].nil?
+            headers[arg] = sum.length + index
+            sum += "#{Utils.safe_encode(arg, 'ASCII-8BIT')}\0"
+          end
+          @str_ins[arg] = headers[arg]
+          sum
+        end
+      end
+  
+      def bucket
+        HMapBucket.new(@str_ins[@key], @str_ins[@perfix], @str_ins[@suffix])
+      end
+  
+      # @return [String] the serialized fields of the mafile
+      def serialize
+        bucket.serialize
+      end
+  
+      def description
+        <<-DESC
+          Key #{@key} -> Prefix #{@perfix}, Suffix #{@suffix}
+        DESC
+      end
+  
+      def to_h
+        {
+          'key' => { 'index' => str_ins[@key], 'key' => @key },
+          'perfix' => { 'index' => str_ins[@perfix], 'perfix' => @perfix },
+          'suffix' => { 'index' => str_ins[@suffix], 'suffix' => @suffix }
+        }
+      end
+    end
+  
+    # HMapBucket structure.
+    # @see https://clang.llvm.org/doxygen/structclang_1_1HMapHeader.html
+    # @abstract
+    class HMapBucket < HMapStructure
+      attr_accessor :key, :perfix, :suffix
+  
+      SIZEOF = 12
+
+      FORMAT = 'L=3'
+  
+      def initialize(key, perfix, suffix)
+        @key = key
+        @perfix = perfix
+        @suffix = suffix
+        super()
+      end
+  
+      # @return [String] the serialized fields of the mafile
+      def serialize
+        format = Utils.specialize_format(FORMAT, SWAPPED)
+        [key, perfix, suffix].pack(format)
+      end
+  
+      def to_a
+        [key, perfix, suffix]
+      end
+  
+      def to_h
+        {
+          'key' => key,
+          'perfix' => perfix,
+          'suffix' => suffix
+        }.merge super
+      end
+    end
+  
+    # HMap blobs.
+    class HMapData
+      def initialize(buckets)
+        super()
+        count = buckets.count
+        nums = num_buckets(count, Utils.next_power_of_two(count))
+        entries = entries(count, nums)
+        @header = populate_hmap_header(nums, entries)
+        @buckets = add_bucket(buckets, nums)
+      end
+      
+      def num_buckets(count, pow2)
+        if count < 8
+          pow2 <<= 1 if count * 4 >= pow2 * 3
+          pow2 < 8 ? 8 : pow2
+        else
+          index = count > 341 ? 2 : -3
+          padding = count / 85 % 7 + index
+          Utils.next_power_of_two(count * 3 + padding)
+        end
+      end
+  
+      def entries(count, nums)
+        return count if nums == 8
+  
+        last_pow = nums >> 1
+        index = last_pow < 1024 ? 3 : -2
+        count - (last_pow + 1 + index) / 3 + 1 + last_pow
+      end
+  
+      # @return [String] the serialized fields of the mafile
+      def serialize
+        @header.serialize + @buckets.inject('') do |sum, bucket|
+          sum += if bucket.nil?
+                    empty_b = [HEADER_CONST[:HMAP_EMPTY_BUCKT_KEY]]*3
+                    empty_b.pack('L<3')
+                 else
+                   bucket
+                 end
+          sum
+        end
+      end
+  
+      def add_bucket(buckets, num)
+        buckets.each_with_object(Array.new(num)) do |bucket, sum|
+          serialize = bucket.serialize
+          i = Utils.index_of_range(bucket.uuid, num)
+          loop do
+            sum[i] = serialize if sum[i].nil?
+            break if serialize == sum[i]
+  
+            i = Utils.index_of_range(i += 1, num)
+          end
+        end
+      end
+  
+      def populate_hmap_header(num_buckets, entries)
+        strings_offset = HMapHeader.bytesize + HMapBucket.bytesize * num_buckets
+        HMapHeader.new(HEADER_CONST[:HMAP_HEADER_MAGIC_NUMBER],
+                       HEADER_CONST[:HMAP_HEADER_VERSION], 0, strings_offset, entries, num_buckets, 0)
+      end
+    end
+  end
+  

data/lib/cocoapods-hmap-prebuilt/hmap_utils.rb

@@ -0,0 +1,136 @@
+require 'cocoapods'
+
+module HMap
+  # A collection of utility functions used throughout cocoapods-hmap-prebuilt.
+  module Utils
+    HEADER_EXTENSIONS = Pod::Sandbox::FileAccessor::HEADER_EXTENSIONS
+
+    def self.index_of_range(num, range)
+      num &= range - 1
+      num
+    end
+
+    def self.power_of_two?(num)
+      num != 0 && (num & (num - 1)).zero?
+    end
+
+    def self.next_power_of_two(num)
+      num |= (num >> 1)
+      num |= (num >> 2)
+      num |= (num >> 4)
+      num |= (num >> 8)
+      num |= (num >> 16)
+      num |= (num >> 32)
+      num + 1
+    end
+
+    def self.hash_set_value(hash, *args)
+      args.each do |arg|
+        hash.merge(arg)
+      end
+      hash
+    end
+
+    def self.specialize_format(format, swapped)
+      modifier = swapped ? '<' : '>'
+      format.tr('=', modifier)
+    end
+
+    def self.string_downcase_hash(str)
+      str.downcase.bytes.inject(0) do |sum, value|
+        sum += value * 13
+        sum
+      end
+    end
+
+    def self.update_changed_file(path, contents)
+      if path.exist?
+        content_stream = StringIO.new(contents)
+        identical = File.open(path, 'rb') { |f| FileUtils.compare_stream(f, content_stream) }
+        return if identical
+      end
+      path.dirname.mkpath
+      File.open(path, 'w') { |f| f.write(contents) }
+    end
+
+    def self.swapped_magic?(magic, version)
+      magic.eql?(HEADER_CONST[:HMAP_SWAPPED_MAGIC]) && version.eql?(HEADER_CONST[:HMAP_SWAPPED_VERSION])
+    end
+
+    def self.magic?(magic)
+      magic.eql?(HEADER_CONST[:HMAP_SWAPPED_MAGIC]) || magic.eql?(HEADER_CONST[:HMAP_HEADER_MAGIC_NUMBER])
+    end
+
+    def self.safe_encode(string, target_encoding)
+      string.encode(target_encoding)
+    rescue Encoding::InvalidByteSequenceError
+      string.force_encoding(target_encoding)
+    rescue Encoding::UndefinedConversionError
+      string.encode(target_encoding, fallback: lambda { |c|
+        c.force_encoding(target_encoding)
+      })
+    end
+
+    def self.clean_target_build_setting(targets, build_setting)
+      target_xcconfig_path(targets) do |xc|
+        clean_build_setting_to_xcconfig(xc, build_setting)
+      end
+    end
+
+    def self.target_xcconfig_path(targets)
+      targets.each do |target|
+        raise ClassIncludedError.new(target.class, Pod::Target) unless target.is_a?(Pod::Target)
+
+        config_h = Pod::Target.instance_method(:build_settings).bind(target).call
+        config_h.each_key do |configuration_name|
+          xcconfig = target.xcconfig_path(configuration_name)
+          yield(xcconfig) if block_given?
+        end
+      end
+    end
+
+    def self.change_xcconfig_header_search_path(xcconfig, hmap_h, use_headermap: true, save_origin: true)
+      hmap_header_serach_paths = hmap_h.inject('') do |sum, hmap_n|
+        hmap_pod_root_path = "${PODS_ROOT}/Headers/#{HMAP_DIR_NAME}/#{hmap_n}"
+        sum + "\"#{hmap_pod_root_path}\" "
+      end
+      save_build_setting_to_xcconfig(xcconfig, hmap_header_serach_paths, HEAD_SEARCH_PATHS, save_origin: save_origin) do |xc|
+        xc.attributes['USE_HEADERMAP'] = 'NO' unless use_headermap
+      end
+    end
+
+    def self.save_build_setting_to_xcconfig(path, value, build_setting, save_origin: true)
+      xc = Xcodeproj::Config.new(path)
+      save_origin_build_setting = "SAVE_#{build_setting}"
+      hmap_build_setting = "HMAP_PREBUILT_#{build_setting}"
+      origin_build_setting = xc.attributes[build_setting]
+
+      if !origin_build_setting.nil? && !origin_build_setting.include?(hmap_build_setting)
+        xc.attributes[save_origin_build_setting] =
+          origin_build_setting
+      end
+
+      save_origin_build_setting_value = xc.attributes[save_origin_build_setting]
+      value = "#{value} ${#{save_origin_build_setting}}" if save_origin && !save_origin_build_setting_value.nil?
+      xc.attributes[hmap_build_setting] = value
+      xc.attributes[build_setting] = "${#{hmap_build_setting}}"
+      yield(xc) if block_given?
+      xc.save_as(path)
+    end
+
+    def self.clean_build_setting_to_xcconfig(path, build_setting)
+      xc = Xcodeproj::Config.new(path)
+      save_origin_build_setting = "SAVE_#{build_setting}"
+      hmap_build_setting = "HMAP_PREBUILT_#{build_setting}"
+      return if xc.attributes[hmap_build_setting].nil?
+
+      xc.attributes[build_setting] = xc.attributes[save_origin_build_setting]
+      xc.attributes.delete(save_origin_build_setting)
+      xc.attributes.delete(hmap_build_setting)
+      xc.attributes['USE_HEADERMAP'] = 'YES'
+      xc.attributes.delete(build_setting) if xc.attributes[build_setting].nil?
+      xc.save_as(path)
+      puts "\t -xcconfig path: #{path} clean finish."
+    end
+  end
+end

data/lib/cocoapods-hmap-prebuilt/hmap_version.rb

@@ -0,0 +1,3 @@
+module CocoapodsHmapPrebuilt
+  VERSION = "0.0.1"
+end

data/lib/cocoapods-hmap-prebuilt/hmap_view.rb

@@ -0,0 +1,29 @@
+
+module HMap
+    # A representation of some unspecified hmap data.
+    class HMapView
+      # @return [String] the raw hmap data
+      attr_reader :raw_data
+  
+      # @return [Symbol] the endianness of the data (`:big` or `:little`)
+      attr_reader :endianness
+  
+      # @return [Integer] the offset of the relevant data (in {#raw_data})
+      attr_reader :offset
+  
+      # Creates a new HMapView.
+      def initialize(raw_data, endianness, offset)
+        @raw_data = raw_data
+        @endianness = endianness
+        @offset = offset
+      end
+  
+      # @return [Hash] a hash representation of this {HMapView}.
+      def to_h
+        {
+          'endianness' => endianness,
+          'offset' => offset
+        }
+      end
+    end
+end

data/lib/cocoapods_plugin.rb

@@ -0,0 +1,11 @@
+require 'cocoapods-hmap-prebuilt/command/hmap_writer'
+require 'cocoapods-hmap-prebuilt/command/hmap_reader'
+
+module CocoapodsHmapPrebuiltHook
+    Pod::HooksManager.register('cocoapods-hmap-prebuilt', :post_install) do
+        Command::HMapWriter.run(["--project-directory=#{Config.instance.installation_root}", "--nosave-origin-header-search-paths"])
+    end
+    Pod::HooksManager.register('cocoapods-hmap-prebuilt', :post_update) do
+        Command::HMapWriter.run(["--project-directory=#{Config.instance.installation_root}", "--nosave-origin-header-search-paths"])
+    end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: cocoapods-hmap-prebuilt
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- EricLou
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: cocoapods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: A short description of cocoapods-hmap-prebuilt.
+email:
+- 499304609@qq.com
+executables:
+- hmap-prebuilt-read
+- hmap-prebuilt-write
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/hmap-prebuilt-read
+- bin/hmap-prebuilt-write
+- lib/cocoapods-hmap-prebuilt.rb
+- lib/cocoapods-hmap-prebuilt/command/hmap_reader.rb
+- lib/cocoapods-hmap-prebuilt/command/hmap_writer.rb
+- lib/cocoapods-hmap-prebuilt/hmap_exceptions.rb
+- lib/cocoapods-hmap-prebuilt/hmap_file.rb
+- lib/cocoapods-hmap-prebuilt/hmap_file_reader.rb
+- lib/cocoapods-hmap-prebuilt/hmap_file_writer.rb
+- lib/cocoapods-hmap-prebuilt/hmap_helper.rb
+- lib/cocoapods-hmap-prebuilt/hmap_struct.rb
+- lib/cocoapods-hmap-prebuilt/hmap_utils.rb
+- lib/cocoapods-hmap-prebuilt/hmap_version.rb
+- lib/cocoapods-hmap-prebuilt/hmap_view.rb
+- lib/cocoapods_plugin.rb
+homepage: http://gitlab.webuy.ai/iOS/cocoapod-hamp-prebuilt.git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+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: A longer description of cocoapods-hmap-prebuilt.
+test_files: []