cocoapods-mapfile 0.2.0 → 0.2.2

data/lib/hmap/helper/pods_helper.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'cocoapods'
+
+module HMap
+  # A collection of Pods Helper functions used throughout cocoapods-hmap.
+  module Pods
+    # mapfile dir name
+    # @api private
+    HMAP_DIR = 'HMap'
+    HEADER_EXTENSIONS = %w[h hh hpp ipp tpp hxx def inl inc].join(',')
+    def self.hmap_files_dir
+      Pathname(File.join(Pod::Config.instance.sandbox.headers_root, HMAP_DIR))
+    end
+
+    def self.pods_hmap_files_dir
+      "${PODS_ROOT}/Headers/#{HMAP_DIR}"
+    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.paths_for_attribute(path)
+      return [] unless path.exist?
+
+      path_list = Pod::Sandbox::PathList.new(path)
+      path_list.glob("**/*.{#{HEADER_EXTENSIONS}}")
+    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[:private_header_files] ||= []
+        sum[:public_header_files] ||= []
+        sum[:source_files] ||= []
+        case type
+        when :private_header_files
+          sum[:private_header_files] += file_accessor.private_headers
+        when :source_files
+          header_mappings_dir = file_accessor.spec_consumer.header_mappings_dir
+          headers = paths_for_attribute(file_accessor.path_list.root)
+          unless header_mappings_dir.nil?
+            headers = paths_for_attribute(file_accessor.path_list.root + header_mappings_dir)
+          end
+          sum[:private_header_files] += file_accessor.private_headers
+          sum[:public_header_files] +=  file_accessor.public_headers
+          sum[:public_header_files] << target.umbrella_header_path if target.build_as_framework?
+          sum[:source_files] << target.prefix_header_path if target.build_as_framework?
+          sum[:source_files] += (headers - file_accessor.public_headers - file_accessor.private_headers)
+        when :public_header_files
+          sum[:public_header_files] += file_accessor.public_headers
+          sum[:public_header_files] << target.umbrella_header_path if target.build_as_framework?
+        end
+      end
+    end
+
+    def self.headers_mappings_by_file(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.compact
+    end
+
+    def self.xcconfig_path_from(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
+
+    def self.clean_hmap_setting(clean_hmap, *targets)
+      return clean_hmap unless clean_hmap
+
+      FileUtils.rm_rf(Pods.hmap_files_dir)
+      targets.each { |target| clean_hmap_build_setting(target, log: true) }
+      clean_hmap
+    end
+
+    def self.clean_hmap_build_setting(targets, log: false)
+      puts 'Clean build setting: '.blue if log
+      targets.each do |target|
+        xcconfig_path_from(target) do |xcconfig|
+          HMap::XcodeprojHelper.new(xcconfig).clean_hmap_build_setting_and_save
+          puts "\t -xcconfig path: #{xcconfig} clean finish." if log
+        end
+      end
+    end
+  end
+end

data/lib/{cocoapods-hmap → hmap/helper}/utils.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: false
 
-require 'cocoapods'
-
 module HMap
   # A collection of utility functions used throughout cocoapods-hmap.
   module Utils
@@ -94,5 +92,3 @@ module HMap
     end
   end
 end
-
-

data/lib/hmap/helper/xcconfig_helper.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module HMap
+  # A collection of xcodeproj Helper functions used throughout hmap.
+  class XcodeprojHelper
+    require 'xcodeproj'
+
+    attr_reader :xcconfig_path, :build_setting_key
+
+    def initialize(xcconfig)
+      @xcconfig_path = xcconfig
+      @xcconfig = Xcodeproj::Config.new(xcconfig_path)
+    end
+
+    def change_hmap_build_setting_and_save(values, use_headermap: false, save_origin: false)
+      ocf = values[BuildSettingConstants::OTHER_CFLAGS]
+      ocppf = values[BuildSettingConstants::OTHER_CPLUSPLUSFLAGS]
+      change_xcconfig_build_setting(BuildSettingConstants::OTHER_CFLAGS, ocf, true)
+      change_xcconfig_build_setting(BuildSettingConstants::OTHER_CPLUSPLUSFLAGS, ocppf, true) if  build_setting?(BuildSettingConstants::OTHER_CPLUSPLUSFLAGS)
+      change_xcconfig_build_setting(BuildSettingConstants::USE_HEADERMAP, 'NO', false) unless use_headermap
+      build_settings = [BuildSettingConstants::HEAD_SEARCH_PATHS, BuildSettingConstants::USER_HEADER_SEARCH_PATHS]
+      if save_origin
+        clean_hmap_build_settings_to_xcconfig(build_settings)
+      else
+        save_build_settings_to_xcconfig(build_settings)
+      end
+      save_to_path
+    end
+
+    def change_xcconfig_build_settings(settings, save_origin)
+      settings.each do |key, value|
+        change_xcconfig_build_setting(key.to_s, value, save_origin)
+      end
+    end
+
+    def change_xcconfig_build_setting(build_setting_key, setting, save_origin)
+      return if setting.nil?
+
+      save_origin_build_setting = save_build_setting_to_xcconfig(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_settings_to_xcconfig(build_settings)
+      build_settings ||= []
+      build_settings.each { |key| save_build_setting_to_xcconfig(key) }
+    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_build_setting_and_save
+      clean_hmap_build_setting_to_xcconfig(BuildSettingConstants::OTHER_CFLAGS)
+      clean_hmap_build_setting_to_xcconfig(BuildSettingConstants::OTHER_CPLUSPLUSFLAGS)
+      clean_hmap_build_setting_to_xcconfig(BuildSettingConstants::HEAD_SEARCH_PATHS)
+      clean_hmap_build_setting_to_xcconfig(BuildSettingConstants::USER_HEADER_SEARCH_PATHS)
+      clean_hmap_build_setting_to_xcconfig(BuildSettingConstants::USE_HEADERMAP)
+      save_to_path
+    end
+
+    def clean_hmap_build_settings_to_xcconfig(build_settings)
+      build_settings ||= []
+      build_settings.each { |build_setting| clean_hmap_build_setting_to_xcconfig(build_setting) }
+    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]
+      if save_origin_build_setting.nil? && !origin_build_setting.nil? && origin_build_setting.include?(hmap_key(build_setting))
+        @xcconfig.attributes.delete(build_setting)
+      end
+      @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 build_setting?(key)
+      !@xcconfig.attributes[key].nil?
+    end
+
+    def hmap_key(key)
+      "HMAP_PODS_#{key}"
+    end
+
+    def save_key(key)
+      "SAVE_#{key}"
+    end
+  end
+end

data/lib/{cocoapods-hmap → hmap}/hmap_reader.rb

@@ -17,6 +17,7 @@ module HMap
       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 → hmap/hmap_saver.rb}

@@ -4,6 +4,12 @@ module HMap
   class HMapSaver
     attr_reader :string_table, :buckets, :headers
 
+    def self.new_from_buckets(buckets)
+      saver = new
+      saver.add_to_buckets(buckets)
+      saver
+    end
+
     def initialize
       @string_table = "\0"
       @buckets = []
@@ -32,13 +38,17 @@ module HMap
       headers[key]
     end
 
-    def add_to_buckets(*buckets)
+    def add_to_bucket(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 add_to_buckets(buckets)
+      buckets.each { |bucket| add_to_bucket(bucket) }
+    end
+
     def write_to(path)
       MapFile.new(@string_table, @buckets).write(path)
     end

data/lib/{cocoapods-hmap → hmap}/hmap_struct.rb

@@ -65,7 +65,7 @@ module HMap
   # @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,
+    # @return [HMap::HMapHeader, 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
 
@@ -112,6 +112,7 @@ module HMap
       }.merge super
     end
   end
+
   # HMapBucket structure.
   # @see https://clang.llvm.org/doxygen/structclang_1_1HMapHeader.html
   # @abstract
@@ -157,7 +158,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
@@ -181,8 +182,8 @@ module HMap
     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')
+                 empty_b = [HEADER_CONST[:HMAP_EMPTY_BUCKT_KEY]] * 3
+                 empty_b.pack('L<3')
                else
                  bucket
                end

data/lib/hmap/hmap_writer.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# require 'cocoapods'
+
+module HMap
+  # 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
+    # @param allow_targets this targets will save origin build setting
+    # @param use_build_in_headermap option use Xcode header map
+    def initialize(save_origin_build_setting, clean_hmap, allow_targets, use_build_in_headermap: true)
+      @allow_targets = allow_targets
+      puts "hmap allow targets: #{allow_targets}" unless allow_targets.empty?
+      @save_origin_build_setting = save_origin_build_setting
+      @use_build_in_headermap = use_build_in_headermap
+      create_mapfile(clean_hmap)
+    end
+
+    private
+
+    # 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)
+      analyze = PodsSpecification.instance.analyze
+      targets = analyze.targets
+      pod_targets = analyze.pod_targets
+      return if Pods.clean_hmap_setting(clean, targets, pod_targets)
+
+      merge_all_pods_target_headers_mapfile(pod_targets)
+      merge_all_target_public_headers_mapfile(targets)
+    end
+
+    def vfs_from_target(target, helper)
+      return unless target.build_as_framework?
+
+      spec_path = target.specs.map(&:defined_in_file).uniq.first
+      platforms = Pods.target_support_platforms(spec_path)
+      headers = Pods.headers_mappings_by_file(target).flat_map { |h| h }
+      helper.add_framework_entry(target.user_build_configurations.keys,
+                                 platforms, target.name, target.product_basename, target.support_files_dir, headers)
+    end
+
+    def hmap_from_header_mappings(target, helper, type = :source_files)
+      Pods.headers_mappings_by_file_accessor(target, type).each do |key, headers|
+        helper.header_mappings(headers, Pod::Config.instance.sandbox.root.join(target.headers_sandbox),
+                               target.product_basename, key)
+      end
+    end
+
+    def hmap_vfs_from_target(target, helper, type = :source_files)
+      vfs_from_target(target, helper)
+      hmap_from_header_mappings(target, helper, type)
+    end
+
+    def merge_all_target_public_headers_mapfile(targets)
+      helper = HMapHelper.new(Pods.hmap_files_dir)
+      targets.each do |target|
+        hmap_name = target.name.to_s
+        target.pod_targets.each do |p_target|
+          hmap_from_header_mappings(p_target, helper, :public_header_files)
+        end
+        change_hmap_build_setting_and_save(target, false, helper, hmap_name, save_origin: @save_origin_build_setting)
+        helper.write_hmap_vfs_to_paths(hmap_name)
+      end
+    end
+
+    def merge_all_pods_target_headers_mapfile(pod_targets)
+      return Pods.clean_hmap_build_setting(pod_targets) if @use_build_in_headermap
+
+      helper = HMapHelper.new(Pods.hmap_files_dir)
+      hmap_name = 'all-pods'
+      pod_targets.each do |target|
+        hmap_vfs_from_target(target, helper)
+        change_hmap_build_setting_and_save(target, target.build_as_framework?, helper, hmap_name,
+                                           save_origin: @save_origin_build_setting)
+      end
+      helper.write_hmap_vfs_to_paths(hmap_name)
+    end
+
+    # Cteate hmap files and vfs files
+    #
+    # @param [target] Pods project target @see Pod#PodTarget
+    # @param [hmap_helper] @see HMap#HMapHelper
+    # @param [hmap_name] hmap file contains pod targets header type
+    # @param [save_origin] save or not save origin build setting
+    def change_hmap_build_setting_and_save(target, build_as_framework, hmap_helper, hmap_name, save_origin: false)
+      save_origin = true if @allow_targets.include?(target.name)
+      setting = hmap_helper.xcconfig_header_setting(build_as_framework, Pods.pods_hmap_files_dir, hmap_name)
+      Pods.xcconfig_path_from(target) do |xcconfig|
+        XcodeprojHelper.new(xcconfig).change_hmap_build_setting_and_save(setting, save_origin: save_origin)
+      end
+    end
+  end
+end

data/lib/hmap/pods_specification.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+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'
+
+    private_constant :BUILD_DIR
+    private_constant :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/hmap/version.rb

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

data/lib/hmap.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# The primary namespace for cocoapods-hmap.
+module HMap
+  require_relative 'hmap/version'
+  require_relative 'hmap/hmap_struct'
+  require_relative 'hmap/helper/pods_helper'
+  require_relative 'hmap/exceptions'
+  require_relative 'hmap/framework/framework_vfs'
+  require_relative 'hmap/hmap_saver'
+  require_relative 'hmap/pods_specification'
+  require_relative 'hmap/helper/xcconfig_helper'
+  require_relative 'hmap/helper/utils'
+  require_relative 'hmap/helper/hmap_helper'
+  require_relative 'hmap/helper/build_setting_constants'
+
+  autoload :Command, 'hmap/command'
+  autoload :MapFileReader, 'hmap/hmap_reader'
+  autoload :MapFileWriter, 'hmap/hmap_writer'
+  autoload :MapFile, 'hmap/mapfile'
+  autoload :Executable, 'hmap/executable'
+end

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-mapfile
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Cat1237
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-10 00:00:00.000000000 Z
+date: 2021-09-23 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
@@ -86,47 +86,47 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.1
+        version: 0.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.1
+        version: 0.0.3
 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
+- hmapfile
 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/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_specification.rb
-- lib/cocoapods-hmap/utils.rb
-- lib/cocoapods-hmap/version.rb
-- lib/cocoapods-hmap/view.rb
-- lib/cocoapods_hmap.rb
+- bin/hmapfile
 - lib/cocoapods_plugin.rb
+- lib/hmap.rb
+- lib/hmap/command.rb
+- lib/hmap/command/hmap_gen.rb
+- lib/hmap/command/hmap_reader.rb
+- lib/hmap/command/hmap_writer.rb
+- lib/hmap/exceptions.rb
+- lib/hmap/executable.rb
+- lib/hmap/framework/framework_vfs.rb
+- lib/hmap/helper/build_setting_constants.rb
+- lib/hmap/helper/hmap_helper.rb
+- lib/hmap/helper/pods_helper.rb
+- lib/hmap/helper/utils.rb
+- lib/hmap/helper/xcconfig_helper.rb
+- lib/hmap/hmap_reader.rb
+- lib/hmap/hmap_saver.rb
+- lib/hmap/hmap_struct.rb
+- lib/hmap/hmap_writer.rb
+- lib/hmap/mapfile.rb
+- lib/hmap/pods_specification.rb
+- lib/hmap/version.rb
 homepage: https://github.com/Cat1237/cocoapods-hmap.git
 licenses:
 - MIT

data/bin/hmap_reader

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