cocoapods-mapfile 0.2.0 → 0.2.2

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

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

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

@@ -1,82 +0,0 @@
-# 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_writer.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require 'cocoapods'
-
-module Pod
-  Validator.class_eval do
-    def results=(v)
-      @results = v
-    end
-  end
-end
-
-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
-  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)
-      @save_origin_header_search_paths = save_origin_header_search_paths
-      @hmap_saver = HMapSaver.new
-      @hmap_saver_iquote = HMapSaver.new
-      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)
-      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)
-
-      merge_all_pods_target_headers_mapfile(pod_targets)
-      merge_all_target_public_headers_mapfile(targets)
-    end
-
-    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 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 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
-
-    # 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 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

@@ -1,60 +0,0 @@
-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/version.rb

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

data/lib/cocoapods-hmap/view.rb

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

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