cocoapods-mapfile 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cc6a56eb46579631d759dfdcabf1b96f05291024207fb6d965ff151dd1b4acb9
+  data.tar.gz: 5815e25f42759074cddd0c76a08c3f23fd6b56f6fd59c92394ef2adf20c149d7
+SHA512:
+  metadata.gz: 9bb22b8025a237b09215a30808d615929f13f2aec2fe2cb96b8dc5f1a20377c7d22ffcc94b1af5d56680d70223128f39707153aa724d7bfb37353425e7260ee8
+  data.tar.gz: 0a34f3b7e122d0efa02b976de35d150f6cdab661a3f051864c57e6db63d47b0667a97a2d0fa22608ef60bc338b31f45abc884eb1864b5baa6a4f9fee826c5b71

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Cat1237
+
+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,106 @@
+# cocoapods-hmap
+
+[![License MIT](https://img.shields.io/badge/license-MIT-green.svg?style=flat)](https://raw.githubusercontent.com/wangson1237/SYCSSColor/master/LICENSE) 
+
+A CocoaPods plugin which can gen/read header map file.
+
+**hmap-gen** is able to scan the header files of the target referenced components in the specified Cocoapods project, and generates a header map file that public to all the components
+as well as generates a public and private header map file for each referenced component.
+
+A hmap file includes four types of headers:
+
+    - header.h
+    - <module/header.h> **based on podspec**
+    - <project_name/header.h> **based on podspec**
+    - <podspec source header/**/header.h> **based on podspec**
+
+At the same time, **hmap-reader** can read the header, bucktes, string_table information saved in the header map file.
+
+- ✅ It can read hmap file.
+
+- ✅ It can generate header map file.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cocoapods-mapfile'
+```
+
+And then execute:
+
+```shell
+# bundle install
+$ bundle install
+```
+
+Or install it yourself as:
+
+```shell
+# gem install
+$ gem install cocoapods-mapfile
+```
+
+## Usage
+
+The command should be executed in directory that contains podfile.
+
+```shell
+# write the hmap file to podfile/Pods/Headers/HMap
+$ pod hmap-gen
+
+# write the hmap file to /project/dir/Pods/Headers/HMap
+$ pod hmap-gen --project-directory=/project/dir/
+
+# write the hmap file to /project/dir/Pods/Headers/HMap and no save origin [HEADER_SEARCH_PATHS]
+$ pod hmap-gen --project-directory=/project/dir/ --nosave-origin-header-search-paths
+
+# cleanup the hmap file
+$ pod hmap-gen --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-mapfile'
+```
+This was equl:
+```rb
+pod hmap-gen --project-directory=/project/dir/ --nosave-origin-header-search-paths
+```
+
+Every time you execute pod install or pod update, `cocoapods-mapfile` will automatically generate a `header map file` for you and modify `HEAD_SEARCH_PATHS`.
+
+### Option && Flags
+
+`hmap-gen/hmap-writer`:
+
+- `--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 path` first.
+- `--clean-hmap`: This option will clean up all `hmap-gen/hmap-writer` setup for hmap.
+
+`hmap-reader`:
+
+- `--hmap-path=/hmap/dir/file`: The path of the hmap file.
+
+## Command Line Tool
+
+Installing the 'cocoapods-mapfile' gem will also install two command-line tool `hmap_reader` and `hmap-writer` which you can use to generate header map file and read hmap file.
+
+For more information consult `hmap_reader --help` or `hmap_writer --help`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [cocoapods-hmap](https://github.com/Cat1237/cocoapods-hmap). This project is intended to be a safe, welcoming space for collaboration.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Cocoapods::Hmap project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/cocoapods-hmap/blob/master/CODE_OF_CONDUCT.md).

data/bin/hmap_reader

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

data/bin/hmap_writer

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

data/lib/cocoapods-hmap/command/hmap_gen.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'cocoapods_hmap'
+require 'cocoapods'
+
+module Pod
+  class Command
+    # hmap file gen cmd
+    class HMapGen < Command
+      # summary
+      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
+
+      # help
+      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-gen setup for hmap.']
+        ].concat(super)
+      end
+
+      def run
+        UI.section "\n[hmap-gen] start.............." do
+          HMap::MapFileWriter.new(@save_origin_header_search_paths, @clean_hmap)
+        end
+        UI.puts('[hmap-gen] finish..............')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: false
+
+require 'cocoapods_hmap'
+require 'cocoapods'
+
+module Pod
+  class Command
+    # hmap file reader cmd
+    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
+        mapfile_path = argv.option('hmap-path')
+        @mapfile_path = Pathname.new(mapfile_path).expand_path unless mapfile_path.nil?
+      end
+
+      def validate!
+        super
+        banner! if help?
+        raise '[ERROR]: --hmap-path no set'.red unless File.exist?(@mapfile_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(@mapfile_path)
+        end
+        UI.puts("\n[hmap-reader] finish..............\n".yellow)
+      end
+    end
+  end
+end

data/lib/cocoapods-hmap/exceptions.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module HMap
+  # A generic HMap error in execution.
+  class HMapError < RuntimeError
+  end
+
+  # Raised when a file is not a HMap.
+  class NotAHMapOError < HMapError
+  end
+
+  # Raised when a file is too short to be a valid HMap file.
+  class TruncatedFileError < NotAHMapOError
+    def initialize
+      super 'File is too short to be a valid HMap'
+    end
+  end
+
+  # Raised when a file's magic bytes are not valid HMap magic.
+  class MagicError < NotAHMapOError
+    # @param num [Integer] the unknown number
+    def initialize(magic)
+      super format('Unrecognized HMap magic: 0x%02<magic>x', magic: magic)
+    end
+  end
+
+  # Raised when a class is not the class of obj.
+  class ClassIncludedError < HMapError
+    def initialize(cls1, cls2)
+      super format('%<cls1>s must be the %<cls2>s of obj', cls1: cls1, cls2: cls2)
+    end
+  end
+end

data/lib/cocoapods-hmap/hmap_reader.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module HMap
+  # hmap file reader
+  class MapFileReader
+    # @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
+
+    private
+
+    # 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
+
+    # description
+    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/hmap_struct.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+# require 'cocoapods-hmap/view'
+
+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 endianness [Symbol] either `:big` or `:little`
+    # @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
+
+    private
+
+    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/hmap_writer.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'cocoapods'
+
+module HMap
+  # mapfile dir name
+  # @api private
+  HMAP_DIR = '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',
+    source_files: 'all'
+  }.freeze
+
+  # build setting HEAD_SEARCH_PATHs
+  HEAD_SEARCH_PATHS = 'HEADER_SEARCH_PATHS'
+  # Helper module which returns handle method from MapFileWriter.
+  class MapFileWriter
+    # @param save_origin_header_search_paths save_origin_header_search_paths
+    # @param clean_hmap clean up all hmap setup
+    def initialize(save_origin_header_search_paths, clean_hmap)
+      config = Pod::Config.instance
+      analyze = Helper::Pods.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_mapfile(targets, pod_targets, hmap_dir)
+    end
+
+    private
+
+    def hmap_dir(config)
+      puts "Current podfile dir: #{config.installation_root}"
+      hmap_dir = File.join(config.sandbox.headers_root, HMAP_DIR)
+      puts "Current 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_mapfile(targets, pod_targets, hmap_d)
+      puts('Inspecting targets to integrate ')
+      merge_all_pods_target_headers_mapfile(pod_targets, hmap_d)
+      merge_all_target_public_mapfile(targets, hmap_d)
+      create_each_target_mapfile(pod_targets, hmap_d)
+    end
+
+    def from_header_mappings_by_file_accessor(header_h, buckets, target, hmap_type)
+      hmap_s = 'headers'
+      hmap_s = "#{HMMAP_TYPE[hmap_type]}_#{hmap_s}" unless hmap_type == :source_files
+      headers = target.header_mappings_by_file_accessor.keys.flat_map(&hmap_s.to_sym)
+      s_headers = Helper::Pods.pod_target_source_header_map(target, hmap_type)
+      headers.each_with_object(buckets) do |header_f, sum|
+        keys = header_perfix(target, header_f, s_headers)
+        sum[0] += header_to_hash(keys, header_h, sum[0].length, sum[1])
+      end
+    end
+
+    def header_perfix(target, file, s_headers)
+      key = file.basename.to_s
+      project_name = "#{target.project_name}/#{file.basename}"
+      product_module_name = "#{target.product_module_name}/#{file.basename}"
+      perfix = "#{file.dirname}/"
+      keys = [key, project_name, product_module_name] + (s_headers[key].nil? ? [] : s_headers[key])
+      keys.compact.uniq.inject([]) do |sum, name|
+        sum << [name, perfix, key]
+      end
+    end
+
+    def header_to_hash(keys, headers, index, buckets)
+      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_name = "All-Pods-Public-#{target.name}-hmap.hmap"
+        single_target_mapfile(target.pod_targets, hmap_dir, hmap_name, method)
+        change_target_xcconfig_header_search_path([hmap_name], true, *targets)
+      end
+    end
+
+    def merge_all_pods_target_headers_mapfile(pod_targets, hmap_dir)
+      method = method(:from_header_mappings_by_file_accessor)
+      hmap_name = 'All-Pods-All-Header-hmap.hmap'
+      single_target_mapfile(pod_targets, hmap_dir, hmap_name, method, :source_files)
+      change_target_xcconfig_header_search_path([hmap_name], true, *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_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_name, method, key)
+          "#{target.name}/#{hmap_name}" if key == :source_files
+        end.compact
+        # change_target_xcconfig_header_search_path(hmap_h, false, target)
+      end
+    end
+
+    def single_target_mapfile(pod_targets, hmap_dir, hmap_name, headers, hmap_type = :public_header_files)
+      hmap_path = Pathname(File.join(hmap_dir, hmap_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_path, buckets)
+    end
+
+    def wirte_mapfile_to_path(hmap_path, buckets)
+      print "\t - save hmap file to path:"
+      puts hmap_path.to_s.yellow
+      MapFile.new(*buckets).write(hmap_path)
+    end
+
+    def change_target_xcconfig_header_search_path(hmap_h, use_headermap, *targets)
+      Utils.target_xcconfig_path(targets) do |xc|
+        Utils.chang_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/mapfile.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module HMap
+  # hmap file writer
+  class MapFile
+    # @return mapfile string_table
+    attr_reader :string_table
+
+    # @return [Array<HMap::HMapBucketStr>] an array of the file's bucktes
+    # @note bucktes are provided in order of ascending offset.
+    attr_reader :buckets
+
+    # @api private
+    def initialize(strings, buckets)
+      @string_table = strings
+      @buckets = buckets
+      @map_data = HMapData.new(buckets)
+    end
+
+    # @return [String] the serialized fields of the mafile
+    def serialize
+      @map_data.serialize + @string_table
+    end
+
+    # Write all mafile data to the given filename.
+    # @param filename [String] the file to write to
+    # @return [void]
+    def write(path)
+      contents = serialize
+      Utils.update_changed_file(path, contents)
+    end
+  end
+end

data/lib/cocoapods-hmap/pods_helper.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'cocoapods'
+
+module HMap
+  # A collection of Helper functions used throughout cocoapods-hmap.
+  module Helper
+    # A collection of Pods Helper functions used throughout cocoapods-hmap.
+    module Pods
+      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.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/utils.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'cocoapods'
+
+module HMap
+  # A collection of utility functions used throughout cocoapods-hmap.
+  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.chang_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}/#{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_PODS_#{build_setting}"
+      origin_build_setting = xc.attributes[build_setting]
+      unless !origin_build_setting.nil? && origin_build_setting.include?(hmap_build_setting)
+        xc.attributes[save_origin_build_setting] =
+          origin_build_setting
+      end
+
+      value = "#{value} ${#{save_origin_build_setting}}" if save_origin
+      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_PODS_#{build_setting}"
+      origin_build_setting = xc.attributes[save_origin_build_setting]
+      puts "\t -xcconfig path: #{path}"
+      if origin_build_setting.nil?
+        puts "\t   don't have #{save_origin_build_setting} in xcconfig file.".red
+        return
+      end
+      xc.attributes[build_setting] = origin_build_setting
+      xc.attributes.delete(save_origin_build_setting)
+      xc.attributes.delete(hmap_build_setting)
+      xc.attributes['USE_HEADERMAP'] = 'YES'
+      xc.save_as(path)
+      puts "\t   clean finish."
+    end
+  end
+end

data/lib/cocoapods-hmap/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CocoapodsHMap
+  VERSION = '0.1.6'
+end

data/lib/cocoapods-hmap/view.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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.
+    # @param raw_data [String] the raw hmap data
+    # @param endianness [Symbol] the endianness of the data
+    # @param offset [Integer] the offset of the relevant data
+    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_hmap.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# The primary namespace for cocoapods-hmap.
+module HMap
+  require_relative 'cocoapods-hmap/version'
+  require_relative 'cocoapods-hmap/view'
+  require_relative 'cocoapods-hmap/hmap_struct'
+  require_relative 'cocoapods-hmap/utils'
+  require_relative 'cocoapods-hmap/pods_helper'
+  require_relative 'cocoapods-hmap/exceptions'
+
+  autoload :MapFileReader, 'cocoapods-hmap/hmap_reader'
+  autoload :MapFileWriter, 'cocoapods-hmap/hmap_writer'
+  autoload :MapFile, 'cocoapods-hmap/mapfile'
+end

data/lib/cocoapods_plugin.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'cocoapods-hmap/command/hmap_gen'
+require 'cocoapods-hmap/command/hmap_reader'
+
+module Pod
+  # hook
+  module CocoaPodsHMapHook
+    HooksManager.register('cocoapods-mapfile', :post_install) do
+      Command::HMapGen.run(["--project-directory=#{Config.instance.installation_root}", "--nosave-origin-header-search-paths"])
+    end
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: cocoapods-mapfile
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+platform: ruby
+authors:
+- Cat1237
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-07-06 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: header_reader lets your read Xcode header map file. header-writer lets
+  your analyze the project pod dependencies and gen header map file for all pods.
+email:
+- wangson1237@outlook.com
+executables:
+- hmap_reader
+- hmap_writer
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/hmap_reader
+- bin/hmap_writer
+- lib/cocoapods-hmap/command/hmap_gen.rb
+- lib/cocoapods-hmap/command/hmap_reader.rb
+- lib/cocoapods-hmap/exceptions.rb
+- lib/cocoapods-hmap/hmap_reader.rb
+- lib/cocoapods-hmap/hmap_struct.rb
+- lib/cocoapods-hmap/hmap_writer.rb
+- lib/cocoapods-hmap/mapfile.rb
+- lib/cocoapods-hmap/pods_helper.rb
+- lib/cocoapods-hmap/utils.rb
+- lib/cocoapods-hmap/version.rb
+- lib/cocoapods-hmap/view.rb
+- lib/cocoapods_hmap.rb
+- lib/cocoapods_plugin.rb
+homepage: https://github.com/Cat1237/cocoapods-hmap.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.1.6
+signing_key:
+specification_version: 4
+summary: Read or write header map file.
+test_files: []