cocoapods-mapfile 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc6a56eb46579631d759dfdcabf1b96f05291024207fb6d965ff151dd1b4acb9
-  data.tar.gz: 5815e25f42759074cddd0c76a08c3f23fd6b56f6fd59c92394ef2adf20c149d7
+  metadata.gz: 7e843368c99922210970ea7de9ab8d2bcc895a158901d054a1cd076d29d73310
+  data.tar.gz: 8f7430064b4472cb4fd6c9fa42dfdd7a144d314c702ab7500a42b0ff302d9ab5
 SHA512:
-  metadata.gz: 9bb22b8025a237b09215a30808d615929f13f2aec2fe2cb96b8dc5f1a20377c7d22ffcc94b1af5d56680d70223128f39707153aa724d7bfb37353425e7260ee8
-  data.tar.gz: 0a34f3b7e122d0efa02b976de35d150f6cdab661a3f051864c57e6db63d47b0667a97a2d0fa22608ef60bc338b31f45abc884eb1864b5baa6a4f9fee826c5b71
+  metadata.gz: e1b0fbf54c2976dd6f7fcba6eca0d1d421a1df6360216e2049643d6ec1133592f19ce49786f58d0c100d71ce923492cf0135be75cbffbaae6e5a40f8b2a1c749
+  data.tar.gz: 9429682a00e5c633baf19f845f691b7fd64b6fa687af9afcb776b5beb86245338e5d1b2d910482809f66d91f660fb02e69c6ce1d3026922f1c6cf447e4345d0d

data/README.md

@@ -7,6 +7,11 @@ 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.
 
+    - `<header.h>` : -I<hmap file path>
+    - `header.h` : iquote <hmap file path>
+
+For framework, use [yaml-vfs](https://github.com/Cat1237/yaml-vfs) create VFS file to map framework Headers and Modules dir and pass VFS file to `-ivfsoverlay` parameter.
+
 A hmap file includes four types of headers:
 
     - header.h
@@ -70,7 +75,7 @@ plugin 'cocoapods-mapfile'
 ```
 This was equl:
 ```rb
-pod hmap-gen --project-directory=/project/dir/ --nosave-origin-header-search-paths
+pod hmap-gen --project-directory=/project/dir/ 
 ```
 
 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`.

data/lib/cocoapods-hmap/executable.rb

@@ -0,0 +1,230 @@
+module HMap
+  module Executable
+    # Creates the methods for the executable with the given name.
+    #
+    # @param  [Symbol] name
+    #         the name of the executable.
+    #
+    # @return [void]
+    #
+    def executable(name)
+      define_method(name) do |*command|
+        Executable.execute_command(name, Array(command).flatten, false)
+      end
+
+      define_method(name.to_s + '!') do |*command|
+        Executable.execute_command(name, Array(command).flatten, true)
+      end
+    end
+
+    # Executes the given command displaying it if in verbose mode.
+    #
+    # @param  [String] executable
+    #         The binary to use.
+    #
+    # @param  [Array<#to_s>] command
+    #         The command to send to the binary.
+    #
+    # @param  [Bool] raise_on_failure
+    #         Whether it should raise if the command fails.
+    #
+    # @raise  If the executable could not be located.
+    #
+    # @raise  If the command fails and the `raise_on_failure` is set to true.
+    #
+    # @return [String] the output of the command (STDOUT and STDERR).
+    #
+    def self.execute_command(executable, command, raise_on_failure = true)
+      bin = which!(executable)
+
+      command = command.map(&:to_s)
+      if File.basename(bin) == 'tar.exe'
+        # Tar on Windows needs --force-local
+        command.push('--force-local')
+      end
+      full_command = "#{bin} #{command.join(' ')}"
+
+      if Pod::Config.instance.verbose?
+        p("$ #{full_command}")
+        stdout = Indenter.new(STDOUT)
+        stderr = Indenter.new(STDERR)
+      else
+        stdout = Indenter.new
+        stderr = Indenter.new
+      end
+
+      status = popen3(bin, command, stdout, stderr)
+      stdout = stdout.join
+      stderr = stderr.join
+      output = stdout + stderr
+      unless status.success?
+        if raise_on_failure
+          raise Informative, "#{full_command}\n\n#{output}"
+        else
+          p("[!] Failed: #{full_command}".red)
+        end
+      end
+
+      stdout
+    end
+
+    # Returns the absolute path to the binary with the given name on the current
+    # `PATH`, or `nil` if none is found.
+    #
+    # @param  [String] program
+    #         The name of the program being searched for.
+    #
+    # @return [String,Nil] The absolute path to the given program, or `nil` if
+    #                      it wasn't found in the current `PATH`.
+    #
+    def self.which(program)
+      program = program.to_s
+      paths = ENV.fetch('PATH') { '' }.split(File::PATH_SEPARATOR)
+      paths.unshift('./')
+      paths.uniq!
+      paths.each do |path|
+        bin = File.expand_path(program, path)
+        bin += '.exe' if Gem.win_platform?
+        return bin if File.file?(bin) && File.executable?(bin)
+      end
+      nil
+    end
+
+    # Returns the absolute path to the binary with the given name on the current
+    # `PATH`, or raises if none is found.
+    #
+    # @param  [String] program
+    #         The name of the program being searched for.
+    #
+    # @return [String] The absolute path to the given program.
+    #
+    def self.which!(program)
+      which(program).tap do |bin|
+        raise Informative, "Unable to locate the executable `#{program}`" unless bin
+      end
+    end
+
+    # Runs the given command, capturing the desired output.
+    #
+    # @param  [String] executable
+    #         The binary to use.
+    #
+    # @param  [Array<#to_s>] command
+    #         The command to send to the binary.
+    #
+    # @param  [Symbol] capture
+    #         Whether it should raise if the command fails.
+    #
+    # @param  [Hash] env
+    #         Environment variables to be set for the command.
+    #
+    # @raise  If the executable could not be located.
+    #
+    # @return [(String, Process::Status)]
+    #         The desired captured output from the command, and the status from
+    #         running the command.
+    #
+    def self.capture_command(executable, command, capture: :merge, env: {}, **kwargs)
+      bin = which!(executable)
+
+      require 'open3'
+      command = command.map(&:to_s)
+      case capture
+      when :merge then Open3.capture2e(env, [bin, bin], *command, **kwargs)
+      when :both then Open3.capture3(env, [bin, bin], *command, **kwargs)
+      when :out then Open3.capture3(env, [bin, bin], *command, **kwargs).values_at(0, -1)
+      when :err then Open3.capture3(env, [bin, bin], *command, **kwargs).drop(1)
+      when :none then Open3.capture3(env, [bin, bin], *command, **kwargs).last
+      end
+    end
+
+    # (see Executable.capture_command)
+    #
+    # @raise  If running the command fails
+    #
+    def self.capture_command!(executable, command, **kwargs)
+      capture_command(executable, command, **kwargs).tap do |result|
+        result = Array(result)
+        status = result.last
+        unless status.success?
+          output = result[0..-2].join
+          raise Informative, "#{executable} #{command.join(' ')}\n\n#{output}".strip
+        end
+      end
+    end
+
+    def self.popen3(bin, command, stdout, stderr)
+      require 'open3'
+      Open3.popen3(bin, *command) do |i, o, e, t|
+        reader(o, stdout)
+        reader(e, stderr)
+        i.close
+
+        status = t.value
+
+        o.flush
+        e.flush
+        sleep(0.01)
+
+        status
+      end
+    end
+
+    def self.reader(input, output)
+      Thread.new do
+        buf = ''
+        begin
+          loop do
+            buf << input.readpartial(4096)
+            loop do
+              string, separator, buf = buf.partition(/[\r\n]/)
+              if separator.empty?
+                buf = string
+                break
+              end
+              output << (string << separator)
+            end
+          end
+        rescue EOFError, IOError
+          output << (buf << $/) unless buf.empty?
+        end
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # Helper class that allows to write to an {IO} instance taking into account
+    # the UI indentation level.
+    #
+    class Indenter < ::Array
+      # @return [Fixnum] The indentation level of the UI.
+      #
+      attr_reader :indent
+
+      # @return [IO] the {IO} to which the output should be printed.
+      #
+      attr_reader :io
+
+      # Init a new Indenter
+      #
+      # @param [IO] io @see io
+      #
+      def initialize(io = nil)
+        @io = io
+        @indent = ' ' * 1
+      end
+
+      # Stores a portion of the output and prints it to the {IO} instance.
+      #
+      # @param  [String] value
+      #         the output to print.
+      #
+      # @return [void]
+      #
+      def <<(value)
+        super
+        io << "#{indent}#{value}" if io
+      end
+    end
+  end
+end

data/lib/cocoapods-hmap/framework/framework_vfs.rb

@@ -0,0 +1,95 @@
+module HMap
+  module Target
+    class FrameworkEntry
+      attr_reader :configuration, :platform, :app_build_dir, :project_temp_dir
+      attr_accessor :headers_real_paths, :modules_real_paths
+
+      def initialize(configuration, platform, app_build_dir, project_temp_dir)
+        @configuration = configuration
+        @platform = platform
+        @app_build_dir = app_build_dir
+        @project_temp_dir = project_temp_dir
+        @headers_real_paths = []
+        @modules_real_paths = []
+      end
+
+      def framework_moduler_path
+        File.join(app_build_dir, 'Modules')
+      end
+
+      def self.new_from_configuration_platform(configuration, platform, name, framework_name)
+        dir = "#{configuration}-#{platform}"
+        app_build_dir = File.join(PodsSpecification.instance.app_build_dir, dir, name,
+                                  "#{framework_name}.framework")
+        project_temp_dir = File.join(PodsSpecification.instance.project_temp_dir, dir, "#{name}.build")
+        new(configuration, platform, app_build_dir, project_temp_dir)
+      end
+
+      def self.new_entrys_from_configurations_platforms(configurations, platforms, name, framework_name, module_path, headers)
+        effective_platforms = Utils.effective_platforms_names(platforms)
+        configurations.flat_map do |configuration|
+          effective_platforms.map do |platform|
+            entry = new_from_configuration_platform(configuration, platform, name, framework_name)
+            entry.add_headers_modules(module_path, framework_name, headers)
+            entry
+          end
+        end
+      end
+
+      def add_headers_modules(module_path, framework_name, headers)
+        has_private_module = module_path.glob('module*.modulemap').length > 1
+        e_headers = ->(path, *names) { names.inject(Pathname(path)) { |e, n| e.join(n) } }
+        @headers_real_paths += headers
+        @headers_real_paths << e_headers.call(app_build_dir, 'Headers',
+                                                   "#{framework_name}-Swift.h")
+        @modules_real_paths << e_headers.call(project_temp_dir, 'module.modulemap')
+        if has_private_module
+          @modules_real_paths << e_headers.call(entry.project_temp_dir,
+                                                     'module.private.modulemap')
+        end
+      end
+    end
+
+    class FrameworkVFS
+      attr_reader :entrys
+
+      def initialize(entrys = [])
+        @entrys = entrys
+      end
+
+      def vfs_path
+        return {} if entrys.empty?
+
+        entrys.each_with_object({}) do |entry, paths|
+          c = "#{entry.configuration}-#{entry.platform}"
+          paths[c] ||= []
+          paths[c] << entry
+        end
+      end
+
+      def vfs_path_by_platform_and_configuration(platform, config)
+        return vfs_path if platform.nil? && config.nil?
+
+        key = platform if config.nil?
+        key = config if platform.nil?
+        vfs_path.select { |k, _| k.include?(key) }
+      end
+
+      def write(path = nil)
+        vfs_path.each do |key, values|
+          es = values.map do |value|
+            headers_real_paths = value.headers_real_paths
+            modules_real_paths = value.modules_real_paths
+            VFS::FileCollectorEntry.new(Pathname(value.app_build_dir), modules_real_paths, headers_real_paths)
+          end
+          fc = VFS::FileCollector.new(es)
+          pa = Helper::Pods.vfs_files_dir.join(key)
+          pa = File.join(path, key) unless path.nil?
+          pa = Pathname(pa)
+          pa.mkpath unless pa.exist?
+          fc.write_mapping(pa)
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-hmap/helper/build_setting_helper.rb

@@ -0,0 +1,40 @@
+module HMap
+    # A collection of build setting functions used throughout cocoapods-hmap.
+    module BuildSettingHelper
+      def self.clean_hmap(clean_hmap, *targets)
+        return clean_hmap unless clean_hmap
+  
+        FileUtils.rm_rf(Helper::Pods.hmap_files_dir)
+        targets.each { |target| clean_other_c_flags_build_setting(target) }
+        clean_hmap
+      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, target) if block_given?
+          end
+        end
+      end
+  
+      def self.clean_other_c_flags_build_setting(targets)
+        target_xcconfig_path(targets) do |xc, _|
+          c = HMap::XcodeprojHelper.new(xc)
+          c.clean_hmap_xcconfig_other_c_flags_and_save
+          puts "\t -xcconfig path: #{xc} clean finish."
+        end
+      end
+  
+      def self.change_other_c_flags_xcconfig_build_settings(hmap_h, targets, use_headermap: false, save_origin: true)
+        target_xcconfig_path(targets) do |xc, target|
+          c = HMap::XcodeprojHelper.new(xc)
+          c.change_xcconfig_other_c_flags_and_save(hmap_h, target.build_as_framework?, use_headermap: use_headermap,
+                                                                                       save_origin: save_origin)
+        end
+      end
+    end
+  end

data/lib/cocoapods-hmap/helper/pods_helper.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'yaml_vfs'
+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
+
+      def self.hmap_files_dir
+        Pathname(File.join(Pod::Config.instance.sandbox.headers_root, HMAP_DIR))
+      end
+
+      def self.vfs_files_dir
+        hmap_files_dir.join('vfs')
+      end
+
+      def self.hmap_files_paths(name)
+        [hmap_files_dir.join("#{name}.hmap"), hmap_files_dir.join("#{name}-iquote.hmap")]
+      end
+
+      def self.pods_hmap_files_dir
+        "${PODS_ROOT}/Headers/#{HMAP_DIR}"
+      end
+
+      def self.write_vfs_yaml(targets)
+        es = targets.flat_map do |target|
+          if target.build_as_framework?
+            spec_path = target.specs.map(&:defined_in_file).uniq.first
+            platforms = target_support_platforms(spec_path)
+            headers = headers_mappings_by_file_accessor(target)
+            headers << target.umbrella_header_path
+            Target::FrameworkEntry.new_entrys_from_configurations_platforms(target.user_build_configurations.keys, platforms, target.name, target.product_module_name, target.support_files_dir, headers)
+          end
+        end.compact
+        Target::FrameworkVFS.new(es).write
+      end
+
+      def self.target_support_platforms(spec_path)
+        validator = Pod::Validator.new(spec_path, Pod::Config.instance.sources_manager.master.map(&:url))
+        validator.platforms_to_lint(validator.spec).map(&:name)
+      end
+
+      def self.headers_mappings_by_file_accessor(target, type = :source_files)
+        valid_accessors = target.file_accessors.reject { |fa| fa.spec.non_library_specification? }
+        valid_accessors.each_with_object([]) do |file_accessor, sum|
+          sum << case type
+                 when :private_header_files then file_accessor.headers - file_accessor.public_headers
+                 when :source_files then file_accessor.headers
+                 when :public_header_files then file_accessor.public_headers
+                 end
+        end.flatten
+      end
+
+      def self.header_mappings(target, type = :source_files)
+        mappings = {}
+        h_headers = lambda { |headers, h_type|
+          root = Pod::Config.instance.sandbox.root.join(target.headers_sandbox)
+          case h_type
+          when :private_header_files
+            headers << target.prefix_header_path if target.build_as_framework?
+            headers.each do |header|
+              mappings[HEAD_SEARCH_IQUOTE] ||= []
+              mappings[HEAD_SEARCH_IQUOTE] << [header.basename.to_s, "#{header.dirname}/", header.basename.to_s]
+              r_header_path = header.relative_path_from(root)
+              mappings[HEAD_SEARCH_IQUOTE] << [r_header_path.to_s, "#{header.dirname}/", header.basename.to_s]
+            end
+          when :public_header_files
+            headers << target.umbrella_header_path if target.build_as_framework?
+            headers.each do |header|
+              mappings[HEAD_SEARCH_IQUOTE] ||= []
+              mappings[HEAD_SEARCH_IQUOTE] << [header.basename.to_s, "#{target.product_module_name}/",
+                                               header.basename.to_s]
+              r_header_path = header.relative_path_from(root)
+              mappings[HEAD_SEARCH_IQUOTE] << [r_header_path.to_s, "#{header.dirname}/", header.basename.to_s]
+              mappings[HEAD_SEARCH_I] ||= []
+              mappings[HEAD_SEARCH_I] << [r_header_path.to_s, "#{header.dirname}/", header.basename.to_s]
+              mappings[HEAD_SEARCH_I] << [header.basename.to_s, "#{target.product_module_name}/",
+                                          header.basename.to_s]
+
+              mappings[HEAD_SEARCH_I] << ["#{target.product_module_name}/#{header.basename}", "#{header.dirname}/",
+                                          header.basename.to_s]
+            end
+          end
+        }
+
+        valid_accessors = target.file_accessors.reject { |fa| fa.spec.non_library_specification? }
+        valid_accessors.each do |file_accessor|
+          case type
+          when :private_header_files then h_headers.call(file_accessor.headers - file_accessor.public_headers,
+                                                         :private_header_files)
+          when :source_files
+            h_headers.call(file_accessor.headers - file_accessor.public_headers, :private_header_files)
+            h_headers.call(file_accessor.public_headers, :public_header_files)
+          when :public_header_files then h_headers.call(file_accessor.public_headers, :public_header_files)
+          end
+        end
+        mappings
+      end
+    end
+  end
+end

data/lib/cocoapods-hmap/helper/xcconfig_helper.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module HMap
+  # A collection of Helper functions used throughout cocoapods-hmap.
+  class XcodeprojHelper
+    require 'xcodeproj'
+    OTHER_CFLAGS = 'OTHER_CFLAGS'
+    HEAD_SEARCH_PATHS = 'HEADER_SEARCH_PATHS'
+    # A collection of Pods Helper functions used throughout cocoapods-hmap.
+    attr_reader :xcconfig_path, :build_setting_key
+
+    def initialize(xcconfig)
+      @xcconfig_path = xcconfig
+      @xcconfig = Xcodeproj::Config.new(xcconfig_path)
+    end
+
+    def change_xcconfig_other_c_flags_and_save(values, build_as_framework, use_headermap: false, save_origin: true)
+      setting = values.flat_map do |config|
+        ['$(inherited)', "-I\"#{Helper::Pods.pods_hmap_files_dir}/#{config}.hmap\"",
+         "-iquote \"#{Helper::Pods.pods_hmap_files_dir}/#{config}-iquote.hmap\""]
+      end
+      if build_as_framework
+        setting << "-ivfsoverlay \"#{Helper::Pods.pods_hmap_files_dir}/vfs/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/all-product-headers.yaml\""
+      end
+      change_xcconfig_build_setting(OTHER_CFLAGS, setting.join(' '), save_origin) do |xcconfig|
+        xcconfig.attributes['USE_HEADERMAP'] = 'NO' unless use_headermap
+        save_build_setting_to_xcconfig(HMap::XcodeprojHelper::HEAD_SEARCH_PATHS)
+      end
+      save_to_path
+    end
+
+    def change_xcconfig_build_setting(build_setting_key, setting, save_origin)
+      origin_build_setting = @xcconfig.attributes[build_setting_key]
+      save_origin_build_setting = save_build_setting_to_xcconfig(build_setting_key)
+      hmap_build_setting = @xcconfig.attributes[hmap_key(build_setting_key)]
+      value = setting
+      value = "#{value} ${#{save_key(build_setting_key)}}" if save_origin && !save_origin_build_setting.nil?
+      @xcconfig.attributes[hmap_key(build_setting_key)] = value
+      @xcconfig.attributes[build_setting_key] = "${#{hmap_key(build_setting_key)}}"
+      yield(@xcconfig) if block_given?
+    end
+
+    def save_build_setting_to_xcconfig(key)
+      origin_build_setting = @xcconfig.attributes[key]
+      if origin_build_setting.nil? || !origin_build_setting.include?(hmap_key(key))
+        @xcconfig.attributes[save_key(key)] = origin_build_setting unless origin_build_setting.nil?
+        @xcconfig.attributes.delete(key)
+      end
+      @xcconfig.attributes[save_key(key)]
+    end
+
+    def clean_hmap_xcconfig_other_c_flags_and_save
+      clean_hmap_build_setting_to_xcconfig(OTHER_CFLAGS)
+      clean_hmap_build_setting_to_xcconfig(HEAD_SEARCH_PATHS)
+      @xcconfig.attributes['USE_HEADERMAP'] = 'YES'
+      save_to_path
+    end
+
+    def clean_hmap_build_setting_to_xcconfig(build_setting)
+      save_origin_build_setting = @xcconfig.attributes[save_key(build_setting)]
+      origin_build_setting = @xcconfig.attributes[build_setting]
+      @xcconfig.attributes[build_setting] = save_origin_build_setting unless save_origin_build_setting.nil?
+      @xcconfig.attributes.delete(hmap_key(build_setting))
+      @xcconfig.attributes.delete(save_key(build_setting))
+    end
+
+    def save_to_path(path = nil)
+      path = xcconfig_path if path.nil?
+      @xcconfig.save_as(path)
+    end
+
+    private
+
+    def hmap_key(key)
+      "HMAP_PODS_#{key}"
+    end
+
+    def save_key(key)
+      "SAVE_#{key}"
+    end
+  end
+end

data/lib/cocoapods-hmap/hmap_reader.rb

@@ -1,6 +1,22 @@
 # frozen_string_literal: true
 
 module HMap
+  # hmap bucket
+  class HMapBucketStr
+    attr_reader :key, :perfix, :suffix
+
+    def initialize(key, perfix, suffix)
+      @key = key
+      @perfix = perfix
+      @suffix = suffix
+    end
+
+    def description
+      <<-DESC
+        Key #{@key} -> Prefix #{@perfix}, Suffix #{@suffix}
+      DESC
+    end
+  end
   # hmap file reader
   class MapFileReader
     # @return [String, nil] the filename loaded from, or nil if loaded from a binary

data/lib/cocoapods-hmap/hmap_save.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module HMap
+  class HMapSaver
+    attr_reader :string_table, :buckets, :headers
+
+    def initialize
+      @string_table = "\0"
+      @buckets = []
+      @headers = {}
+    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 add_to_string_table(str)
+      @string_table += "#{Utils.safe_encode(str, 'ASCII-8BIT')}\0"
+    end
+
+    def add_to_headers(key)
+      if headers[key].nil?
+        headers[key] = string_table.length
+        add_to_string_table(key)
+      end
+      headers[key]
+    end
+
+    def add_to_buckets(*buckets)
+      values = buckets.map { |key| add_to_headers(key) }
+      bucket = HMapBucket.new(*values)
+      bucket.uuid = Utils.string_downcase_hash(buckets.first)
+      @buckets << bucket
+    end
+
+    def write_to(path)
+      MapFile.new(@string_table, @buckets).write(path)
+    end
+  end
+end

data/lib/cocoapods-hmap/hmap_struct.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# require 'cocoapods-hmap/view'
-
 module HMap
   HEADER_CONST = {
     HMAP_HEADER_MAGIC_NUMBER: 0x686d6170,
@@ -114,62 +112,11 @@ module HMap
       }.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
+    attr_accessor :key, :perfix, :suffix, :uuid
 
     SIZEOF = 12
     FORMAT = 'L=3'
@@ -210,7 +157,7 @@ module HMap
       @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

data/lib/cocoapods-hmap/hmap_writer.rb

@@ -2,6 +2,14 @@
 
 require 'cocoapods'
 
+module Pod
+  Validator.class_eval do
+    def results=(v)
+      @results = v
+    end
+  end
+end
+
 module HMap
   # mapfile dir name
   # @api private
@@ -16,130 +24,84 @@ module HMap
     private_header_files: 'private',
     source_files: 'all'
   }.freeze
-
+  HEAD_SEARCH_I = '-I'
+  HEAD_SEARCH_IQUOTE = '-iquote'
   # 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)
+      @hmap_saver = HMapSaver.new
+      @hmap_saver_iquote = HMapSaver.new
+      create_mapfile(clean_hmap)
     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
+    # Integrates the projects mapfile associated
+    # with the App project and Pods project.
+    #
+    # @param  [clean] clean hmap dir @see #podfile
+    # @return [void]
+    #
+    def create_mapfile(clean)
+      puts "Current hmap files dir: #{Helper::Pods.hmap_files_dir}"
+      puts "Current vfs files dir: #{Helper::Pods.vfs_files_dir}"
+      analyze = PodsSpecification.instance.analyze
+      targets = analyze.targets
+      pod_targets = analyze.pod_targets
+      return if BuildSettingHelper.clean_hmap(clean, targets, pod_targets)
 
-    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
+      merge_all_pods_target_headers_mapfile(pod_targets)
+      merge_all_target_public_headers_mapfile(targets)
     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)
+    def from_header_mappings(target, type = :source_files)
+      headers = Helper::Pods.header_mappings(target, type)
+      headers[HEAD_SEARCH_IQUOTE].each { |value| @hmap_saver_iquote.add_to_buckets(*value) }
+      headers[HEAD_SEARCH_I].each { |value| @hmap_saver.add_to_buckets(*value) }
     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)
+    def merge_all_target_public_headers_mapfile(targets)
+      names = targets.map do |target|
+        hmap_name = "all-public-#{target.name}"
+        create_hmap_vfs_files(target.pod_targets, hmap_name, :public_header_files)
+        hmap_name
       end
+      BuildSettingHelper.change_other_c_flags_xcconfig_build_settings(names, targets,
+                                                  save_origin: @save_origin_header_search_paths)
     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)
+    def merge_all_pods_target_headers_mapfile(pod_targets)
+      hmap_name = 'all-pods-all-header'
+      create_hmap_vfs_files(pod_targets, hmap_name, :source_files)
+      BuildSettingHelper.change_other_c_flags_xcconfig_build_settings([hmap_name], pod_targets,
+                                                  save_origin: @save_origin_header_search_paths)
     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)
+    # Cteate hmap files and vfs files
+    #
+    # @param [pod_targets] Pods project all target @see Pod#PodTarget
+    # @param [hmap_name] -I hmap file name and -iquote hmap file name
+    # @param [hmap_type] hmap file contains pod targets header type
+    #
+    def create_hmap_vfs_files(pod_targets, hmap_name, hmap_type = :public_header_files)
+      pod_targets.each { |target| from_header_mappings(target, hmap_type) }
+      Helper::Pods.write_vfs_yaml(pod_targets)
+      write_hmap_files(*Helper::Pods.hmap_files_paths(hmap_name))
     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
+    def write_hmap_files(hmap_path_i, hmap_path_iquote)
+      print "\t - Save hmap file to path: "
+      puts hmap_path_i.to_s.yellow
+      print "\t - Save hmap file to path: "
+      puts hmap_path_iquote.to_s.yellow
+      @hmap_saver.write_to(hmap_path_i)
+      @hmap_saver_iquote.write_to(hmap_path_iquote)
     end
   end
 end

data/lib/cocoapods-hmap/pods_specification.rb

@@ -0,0 +1,60 @@
+module HMap
+    class PodsSpecification
+      attr_reader :workspace_path, :analyze, :app_build_dir, :project_temp_dir
+  
+      BUILD_DIR = 'BUILD_DIR'
+      PROJECT_TEMP_DIR = 'PROJECT_TEMP_DIR'
+  
+      def self.instance
+        @instance ||= new
+      end
+  
+      def initialize
+        @workspace_path = workspace
+        @analyze = pod_analyze
+        workspace_build_dir
+      end
+  
+      private
+  
+      def workspace_build_dir
+        workspace_dic = xcodebuild('-list', workspace_path)['workspace']
+        scheme = workspace_dic['schemes'].first
+        build_settings = xcodebuild('analyze', workspace_path, scheme).first['buildSettings']
+        @app_build_dir = build_settings[BUILD_DIR]
+        @project_temp_dir = build_settings[PROJECT_TEMP_DIR]
+      end
+  
+      def xcodebuild(action, workspace, scheme = nil)
+        command = %W[#{action} -workspace #{workspace} -json]
+        command += %W[-scheme #{scheme} -showBuildSettings] unless scheme.nil?
+        results = Executable.execute_command('xcodebuild', command, false)
+        JSON.parse(results) unless results.nil?
+      end
+  
+      def pod_analyze
+        podfile = Pod::Podfile.from_file(Pod::Config.instance.podfile_path)
+        lockfile = Pod::Lockfile.from_file(Pod::Config.instance.lockfile_path)
+        Pod::Installer::Analyzer.new(Pod::Config.instance.sandbox, podfile, lockfile).analyze
+      end
+  
+      def workspace
+        podfile = Pod::Podfile.from_file(Pod::Config.instance.podfile_path)
+        user_project_paths = pod_analyze.targets.map(&:user_project_path).compact.uniq
+        if podfile.workspace_path
+          declared_path = podfile.workspace_path
+          path_with_ext = File.extname(declared_path) == '.xcworkspace' ? declared_path : "#{declared_path}.xcworkspace"
+          podfile_dir   = File.dirname(podfile.defined_in_file || '')
+          absolute_path = File.expand_path(path_with_ext, podfile_dir)
+          Pathname.new(absolute_path)
+        elsif user_project_paths.count == 1
+          project = user_project_paths.first.basename('.xcodeproj')
+          Pod::Config.instance.installation_root + "#{project}.xcworkspace"
+        else
+          raise Informative, 'Could not automatically select an Xcode ' \
+            "workspace. Specify one in your Podfile like so:\n\n"       \
+            "    workspace 'path/to/Workspace.xcworkspace'\n"
+        end
+      end
+    end
+  end

data/lib/cocoapods-hmap/utils.rb

@@ -1,11 +1,31 @@
-# frozen_string_literal: true
+# frozen_string_literal: false
 
 require 'cocoapods'
 
 module HMap
   # A collection of utility functions used throughout cocoapods-hmap.
   module Utils
-    HEADER_EXTENSIONS = Pod::Sandbox::FileAccessor::HEADER_EXTENSIONS
+    # Converts the symbolic name of a platform to a string name suitable to be
+    # presented to the user.
+    #
+    # @param  [Symbol] symbolic_name
+    #         the symbolic name of a platform.
+    #
+    # @return [String] The string that describes the name of the given symbol.
+    #
+    def self.effective_platform_name(symbolic_name)
+      case symbolic_name
+      when :ios then %w[iphoneos iphonesimulator]
+      when :osx then %w[macosx]
+      when :watchos then %w[watchos watchsimulator]
+      when :tvos then %w[appletvos appletvsimulator]
+      else []
+      end
+    end
+
+    def self.effective_platforms_names(platforms)
+      platforms.flat_map { |name| effective_platform_name(name) }.compact.uniq
+    end
 
     def self.index_of_range(num, range)
       num &= range - 1
@@ -72,69 +92,7 @@ module HMap
         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

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

data/lib/cocoapods-hmap/view.rb

@@ -31,3 +31,4 @@ module HMap
     end
   end
 end
+

data/lib/cocoapods_hmap.rb

@@ -6,10 +6,16 @@ module HMap
   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/helper/pods_helper'
   require_relative 'cocoapods-hmap/exceptions'
+  require_relative 'cocoapods-hmap/framework/framework_vfs'
+  require_relative 'cocoapods-hmap/hmap_save'
+  require_relative 'cocoapods-hmap/helper/xcconfig_helper'
+  require_relative 'cocoapods-hmap/pods_specification'
+  require_relative 'cocoapods-hmap/helper/build_setting_helper'
 
   autoload :MapFileReader, 'cocoapods-hmap/hmap_reader'
   autoload :MapFileWriter, 'cocoapods-hmap/hmap_writer'
   autoload :MapFile, 'cocoapods-hmap/mapfile'
+  autoload :Executable, 'cocoapods-hmap/executable'
 end

data/lib/cocoapods_plugin.rb

@@ -7,7 +7,7 @@ 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"])
+      Command::HMapGen.run(["--project-directory=#{Config.instance.installation_root}"])
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-mapfile
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Cat1237
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-06 00:00:00.000000000 Z
+date: 2021-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: yaml-vfs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
 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:
@@ -97,11 +111,17 @@ files:
 - lib/cocoapods-hmap/command/hmap_gen.rb
 - lib/cocoapods-hmap/command/hmap_reader.rb
 - lib/cocoapods-hmap/exceptions.rb
+- lib/cocoapods-hmap/executable.rb
+- lib/cocoapods-hmap/framework/framework_vfs.rb
+- lib/cocoapods-hmap/helper/build_setting_helper.rb
+- lib/cocoapods-hmap/helper/pods_helper.rb
+- lib/cocoapods-hmap/helper/xcconfig_helper.rb
 - lib/cocoapods-hmap/hmap_reader.rb
+- lib/cocoapods-hmap/hmap_save.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/pods_specification.rb
 - lib/cocoapods-hmap/utils.rb
 - lib/cocoapods-hmap/version.rb
 - lib/cocoapods-hmap/view.rb
@@ -126,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: Read or write header map file.

data/lib/cocoapods-hmap/pods_helper.rb

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