cocoapods-mapfile 0.2.2 → 0.2.3

data/lib/hmap/helper/xcconfig_helper.rb

@@ -1,105 +0,0 @@
-# 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/hmap/hmap_writer.rb

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

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