cocoapods-hmap-prebuilt 0.0.2 → 0.0.7

data/README.md

@@ -1,40 +0,0 @@
-# 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

@@ -1,10 +0,0 @@
-#!/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

@@ -1,10 +0,0 @@
-#!/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/command/hmap_reader.rb

@@ -1,39 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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_exceptions.rb

@@ -1,30 +0,0 @@
-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
-    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-prebuilt/hmap_file.rb

@@ -1,31 +0,0 @@
-module HMap
-  class HMapFile
-    # @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-prebuilt/hmap_file_reader.rb

@@ -1,91 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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