cocoapods-mapfile 0.2.0 → 0.2.5

data/lib/hmap/xc/target/build_setting.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+require 'hmap/xc/target/target_vfs'
+
+module HMap
+  class Platform
+    attr_reader :configuration, :platform
+
+    def self.new_from_platforms(configuration, platforms)
+      Utils.effective_platforms_names(platforms).map { |pl| new(configuration, pl) }
+    end
+
+    def initialize(configuration, platform)
+      @configuration = configuration
+      @platform = platform
+    end
+
+    def to_s
+      "#{configuration}-#{platform}"
+    end
+  end
+end
+
+module HMap
+  class BuildSettings
+    attr_reader :type, :platform
+
+    def self.new_from_platforms(type, platforms, context)
+      platforms.map { |platform| new(type, platform.to_s, context) }
+    end
+
+    def initialize(type, platform, context)
+      @type = type
+      @platform = platform.to_s || ''
+      @context = context
+    end
+
+    def write_or_symlink(path, data, need_platform)
+      return if data.nil? && path.nil?
+
+      if data.nil?
+        dir = platform if type == :all_product_headers
+        path = Constants.instance.full_hmap_filepath(type, path, dir)
+        symlink_to(path, need_platform)
+      else
+        write(data, need_platform)
+      end
+    end
+
+    private
+
+    def file_name
+      return @file_name if defined? @file_name
+
+      product_name = @context.product_name if @context.respond_to? :product_name
+      @file_name = Constants.instance.full_hmap_filename(type, product_name)
+    end
+
+    def hmap_filepath(need_platform)
+      platform = ''
+      platform = @platform if need_platform
+      hmap_root = File.join(@context.hmap_root, platform, @context.temp_name)
+      File.join(hmap_root, file_name)
+    end
+
+    def symlink_to(path, need_platform)
+      return unless path.exist?
+
+      filepath = Pathname.new(hmap_filepath(need_platform))
+      filepath.dirname.mkpath unless filepath.exist?
+      return if File.identical?(filepath, path)
+
+      filepath.make_symlink(path)
+    end
+
+    def write(data, need_platform)
+      path = Constants.instance.full_hmap_filepath(type, hmap_filepath(need_platform))
+      if type == :all_product_headers
+        da = data[platform] || []
+        TargetVFSWriter.new(da).write!(path)
+      else
+        HMapSaver.new_from_buckets(data).write_to(path)
+      end
+    end
+  end
+
+  class BuildSettingsWriter
+    attr_reader :platforms
+
+    # Initialize a new instance
+    #
+    # @param  [Array<HMap::Platform>] platforms
+    #         the platforms to lint.
+    #
+    # @param  [HMap::Context] context
+    #         the Project or target information.
+    #
+    def initialize(platforms, context)
+      @platforms = platforms
+      @context = context
+    end
+
+    def write_or_symlink(path, data, platforms = [])
+      build_settings.each do |setting|
+        type_data = data[setting.type] unless data.nil?
+        next if type_data.nil? && path.nil?
+
+        need_platform = platforms.include?(setting.type)
+        setting.write_or_symlink(path, type_data, need_platform)
+      end
+    end
+
+    private
+
+    def build_settings
+      return @build_settings if defined? @build_settings
+
+      @build_settings = Constants::HMAP_FILE_TYPE.flat_map do |type|
+        if @platforms.empty?
+          BuildSettings.new(type, nil, @context)
+        else
+          BuildSettings.new_from_platforms(type, @platforms, @context)
+        end
+      end
+    end
+  end
+end

data/lib/hmap/xc/target/target.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'hmap/xc/target/build_setting'
+require 'hmap/xc/target/target_helper'
+require 'hmap/xc/target/xcconfig_helper'
+
+module HMap
+  class Target
+    include HMap::Target::Helper
+
+    attr_reader :entrys, :target, :project
+
+    def initialize(entrys, target, project)
+      @entrys = entrys || []
+      @target = target
+      @project = project
+    end
+
+    def platforms
+      project.platforms
+    end
+
+    def write_hmapfile!
+      datas = headers_hash(:own_target_headers)
+      build_settings = BuildSettingsWriter.new(platforms, context)
+      build_settings.write_or_symlink(project.context.hmap_root, datas, Constants::HMAP_FILE_TYPE)
+    end
+
+    def save_hmap_settings!
+      xcconfig_paths.each do |path|
+        settings = Constants.instance.hmap_build_settings
+        XcodeprojHelper.new(path).add_build_settings_and_save(settings, use_origin: Resolver.instance.use_origin)
+      end
+    end
+
+    def remove_hmap_settings!
+      xcconfig_paths.each { |path| HMap::XcodeprojHelper.new(path).remove_build_settings_and_save }
+    end
+
+    private
+
+    def xcconfig_paths
+      return @xcconfig_paths if defined?(@xcconfig_paths)
+
+      @xcconfig_paths = target.build_configuration_list.build_configurations.flat_map do |configuration|
+        if configuration.is_a?(Constants::XCBuildConfiguration)
+          bcr = configuration.base_configuration_reference
+          unless bcr.nil?
+            s_path = PBXHelper.group_paths(bcr)
+            x = bcr.instance_variable_get('@simple_attributes_hash')['path'] || ''
+            File.expand_path File.join(project.project_dir, s_path, x)
+          end
+        end
+      end.compact
+      #   @xcconfig_paths = TargetConfiguration.new_from_xc(target, project.project_dir).map do |c|
+      #     c.xcconfig_path unless c.xcconfig_path.nil?
+      #   end.compact
+      # @xcconfig_paths = bc.map(&:xcconfig_path).compact
+      # xc_type = 'XCConfigurationList'
+      # xcs = target.build_configuration_list.build_configurations
+      # @xcconfig_paths = xcs.map do |xc|
+      #   if xc.isa == xc_type
+      #     xc_path = xc.instance_variable_get('@simple_attributes_hash')['path'] || ''
+      #     { xc => File.join(project.project_dir, xc_path) }
+      #   else
+      #     # ab_path = Pathname(project.project_dir + "hmap-#{name}.#{xc.name}.xcconfig")
+      #     # File.new(ab_path, 'w') unless ab_path.exist?
+      #     # xc_ref = target.project.new_file(ab_path)
+      #     # xc.base_configuration_reference = xc_ref
+      #     # target.project.save
+      #     # ab_path
+      #   end
+      # end
+    end
+  end
+end

data/lib/hmap/xc/target/target_context.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module HMap
+  class Target 
+    class TargetContext < Context
+      attr_reader :product_name
+      def initialize(build_root, temp_dir, hmap_root, temp_name, build_dir, product_name, full_product_name, defines_modules, build_as_framework_swift)
+        super(build_root, temp_dir, hmap_root, temp_name, build_dir)
+        @full_product_name = full_product_name
+        @product_name = product_name
+        @defines_modules = defines_modules
+        @build_as_framework_swift = build_as_framework_swift
+      end
+  
+      def build_as_framework_swift?
+        @build_as_framework_swift
+      end
+  
+      def defines_modules?
+        @defines_modules
+      end
+  
+      def build_path(platform)
+        path = super(platform)
+        File.join(path, @full_product_name)
+      end
+    end
+  end
+end

data/lib/hmap/xc/target/target_helper.rb

@@ -0,0 +1,114 @@
+require 'hmap/xc/target/target_context'
+
+module HMap
+  class Target
+    module Helper
+      include HMap::HeaderType
+
+      define_method(:all_product_headers) do
+        return @all_product_headers if defined? @all_product_headers
+
+        public_headers = public_entrys.map(&:path)
+        private_headers = private_entrys.map(&:path)
+        @all_product_headers = TargetVFS.new(public_headers, private_headers, platforms, context).vfs_entrys
+      end
+
+      define_method(:all_non_framework_target_headers) do
+        return if build_as_framework?
+
+        p_h = public_entrys + private_entrys
+        p_h.flat_map { |entry| entry.full_module_buckets(product_name) }
+      end
+
+      # all_targets include header full module path
+      define_method(:all_target_headers) do
+        p_h = public_entrys + private_entrys
+        p_h.flat_map do |entry|
+          entry.full_module_buckets_extra(product_name) + entry.module_buckets(product_name)
+        end
+      end
+
+      define_method(:project_headers) do
+        all_target_headers + project_entrys.flat_map(&:project_buckets_extra)
+      end
+
+      define_method(:own_target_headers) do
+        headers = public_entrys + private_entrys
+        headers = headers.flat_map { |entry| entry.module_buckets(product_name) }
+        headers + project_entrys.flat_map do |entry|
+          entry.project_buckets + entry.full_module_buckets(product_name)
+        end
+      end
+      def build_root
+        project.build_root
+      end
+
+      def hmap_root
+        project.hmap_root
+      end
+
+      def target_name
+        target.name
+      end
+
+      def product_name
+        target.product_name.gsub(/[-]/, '_')
+      end
+
+      def full_product_name
+        target.product_reference.instance_variable_get('@simple_attributes_hash')['path'] || ''
+      end
+
+      def temp_name
+        "#{target_name}.build"
+      end
+
+      def temp_dir
+        project.temp_dir
+      end
+
+      def build_dir
+        return @build_dir if defined?(@build_dir)
+
+        b_d = xcconfig_paths.any? do |path|
+          xc = Xcodeproj::Config.new(path)
+          !xc.attributes[Constants::CONFIGURATION_BUILD_DIR].nil?
+        end
+        @build_dir = target_name if b_d
+      end
+
+      def build_as_framework?
+        PBXHelper.build_as_framework?(target)
+      end
+
+      def build_as_framework_swift?
+        uses_swift? && build_as_framework?
+      end
+
+      def uses_swift?
+        return @uses_swift if defined?(@uses_swift)
+
+        @uses_swift = PBXHelper.uses_swift?(target)
+      end
+
+      def defines_module?
+        return @defines_module if defined?(@defines_module)
+        return @defines_module = true if build_as_framework?
+
+        @defines_module = PBXHelper.defines_module?(target)
+      end
+
+      def context
+        TargetContext.new(build_root,
+                          temp_dir,
+                          hmap_root,
+                          temp_name,
+                          build_dir,
+                          product_name,
+                          full_product_name,
+                          defines_module?,
+                          build_as_framework_swift?)
+      end
+    end
+  end
+end

data/lib/hmap/xc/target/target_vfs.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'yaml_vfs'
+
+module HMap
+  class TargetVFSEntry
+    attr_reader :real_path, :virtual_path
+
+    def initialize(build_dir, file)
+      @real_path = file
+      @virtual_path = File.join(build_dir, File.basename(file))
+    end
+  end
+
+  class TargetPlatformVFS
+    def initialize(platform, setting)
+      @platform = platform
+      @setting = setting
+    end
+
+    def product_name
+      File.basename(build_dir, '.*')
+    end
+
+    def build_dir
+      @setting.build_path(@platform)
+    end
+
+    def temp_dir
+      @setting.temp_path(@platform)
+    end
+
+    def defines_modules?
+      @setting.defines_modules?
+    end
+
+    def module_path
+      File.join(temp_dir, 'module.modulemap') if defines_modules?
+    end
+
+    def private_module_path
+      File.join(temp_dir, 'module.private.modulemap') if defines_modules?
+    end
+
+    def swift_header_path
+      File.join(build_dir, 'Headers', "#{product_name}-Swift.h") if @setting.build_as_framework_swift?
+    end
+
+    def public_headers_dir
+      File.join(build_dir, 'Headers')
+    end
+
+    def private_headers_dir
+      File.join(build_dir, 'PrivateHeaders')
+    end
+
+    def module_dir
+      File.join(build_dir, 'Modules')
+    end
+  end
+
+
+  # A collection of Each TargetVFSEntry
+  class TargetVFS
+    def initialize(public_headers, private_headers, platforms, setting)
+      @setting = setting
+      @platforms = platforms
+      @public_headers = public_headers
+      @private_headers = private_headers
+    end
+
+    def add_headers_modules(config)
+      r_public_paths = []
+      r_public_paths += @public_headers
+      s_h = config.swift_header_path
+      r_public_paths << s_h unless s_h.nil?
+      r_private_paths = []
+      r_private_paths += @private_headers
+      headers = []
+      headers += add_files(r_public_paths, config.public_headers_dir)
+      headers += add_files(r_private_paths, config.private_headers_dir)
+      modules_real_paths = []
+      if config.defines_modules?
+        modules_real_paths << config.module_path
+        modules_real_paths << config.private_module_path unless r_private_paths.empty?
+      end
+      headers += add_files(modules_real_paths, config.module_dir) || []
+      headers
+    end
+
+    def add_files(files, virtual_dir)
+      return if files.nil?
+
+      files.map { |file| TargetVFSEntry.new(virtual_dir, file) }
+    end
+
+    def vfs_entrys
+      Hash[@platforms.map do |platform|
+        config = TargetPlatformVFS.new(platform, @setting)
+        [platform.to_s, add_headers_modules(config)]
+      end]
+    end
+  end
+
+  class TargetVFSWriter
+    attr_reader :entrys
+
+    def initialize(entrys)
+      @entrys = entrys
+    end
+
+    def write!(path)
+      es = @entrys.map do |entry|
+        VFS::FileCollectorEntry.new(entry.real_path, entry.virtual_path)
+      end.uniq
+      fc = VFS::FileCollector.new(es)
+      pa = Pathname.new(path)
+      pa.dirname.mkpath unless pa.exist?
+      fc.write_mapping(pa)
+    end
+  end
+end

data/lib/hmap/xc/target/xcconfig_helper.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module HMap
+  # A collection of xcodeproj Helper functions used throughout hmap.
+  class XcodeprojHelper
+    HMAP_XCKEY_START = 'HMAP_'
+    SAVE_XCKEY_START = 'SAVE_'
+    private_constant :HMAP_XCKEY_START, :SAVE_XCKEY_START
+
+    attr_reader :xcconfig_path
+
+    def initialize(path)
+      xc = Pathname(path)
+      @xcconfig_path = xc
+      @xcconfig = Xcodeproj::Config.new(xc)
+    end
+
+    def add_build_settings_and_save(settings, use_origin: true)
+      add_build_settings(settings, use_origin)
+      build_settings = [Constants::HEADER_SEARCH_PATHS, Constants::USER_HEADER_SEARCH_PATHS]
+      if use_origin
+        remove_build_settings(settings)
+      else
+        save_build_settings(settings)
+      end
+      save_as
+    end
+
+    def add_build_settings(settings, use_origin)
+      settings.each do |key, value|
+        add_build_setting(key.to_s, value, use_origin)
+      end
+    end
+
+    def add_build_setting(key, value, use_origin)
+      return if value.nil?
+
+      if key.start_with?(HMAP_XCKEY_START)
+        @xcconfig.attributes[key] = value
+      else
+        save_origin = save_build_setting(key)
+        e_value = value
+        e_value = "#{e_value} ${#{save_xckey(key)}}" if use_origin && !save_origin.nil?
+        @xcconfig.attributes[hmap_xckey(key)] = e_value
+        @xcconfig.attributes[key] = "${#{hmap_xckey(key)}}"
+      end
+    end
+
+    def save_build_settings(settings)
+      settings ||= []
+      settings.each { |key| save_build_setting(key) }
+    end
+
+    def save_build_setting(key)
+      origin = @xcconfig.attributes[key]
+      if origin.nil? || !origin.include?(hmap_xckey(key))
+        @xcconfig.attributes[save_xckey(key)] = origin unless origin.nil?
+        @xcconfig.attributes.delete(key)
+      end
+      @xcconfig.attributes[save_xckey(key)]
+    end
+
+    def remove_build_settings_and_save
+
+      hmap_ks = @xcconfig.attributes.keys.each_with_object([]) do |key, sum|
+        sum << key[HMAP_XCKEY_START.length..-1] if key.start_with?(HMAP_XCKEY_START)
+        sum << key[SAVE_XCKEY_START.length..-1] if key.start_with?(SAVE_XCKEY_START)
+      end.compact
+      remove_build_settings(hmap_ks)
+      save_as
+    end
+
+    def remove_build_settings(settings)
+      settings ||= []
+      settings.each { |setting| remove_build_setting(setting) }
+    end
+
+    def remove_build_setting(setting)
+      save_origin = @xcconfig.attributes[save_xckey(setting)]
+      origin = @xcconfig.attributes[setting]
+      if save_origin.nil? && !origin.nil? && origin.include?(hmap_xckey(setting))
+        @xcconfig.attributes.delete(setting)
+      end
+      @xcconfig.attributes[setting] = save_origin unless save_origin.nil?
+      @xcconfig.attributes.delete(hmap_xckey(setting))
+      @xcconfig.attributes.delete(save_xckey(setting))
+    end
+
+    def save_as(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_xckey(key)
+      "#{HMAP_XCKEY_START}#{key}"
+    end
+
+    def save_xckey(key)
+      "#{SAVE_XCKEY_START}#{key}"
+    end
+  end
+end

data/lib/hmap/xc/workspace/project.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'hmap/xc/workspace/project_helper'
+require 'hmap/xc/target/target'
+
+module HMap
+  HEADER_FILES_EXTENSIONS = %w[.h .hh .hpp .ipp .tpp .hxx .def .inl .inc .pch]
+
+  class Project
+    include HMap::Project::Helper
+
+    attr_reader :project, :workspace
+
+    def initialize(project, workspace)
+      @project = project
+      @workspace = workspace
+    end
+
+    def platforms
+      return @platforms if defined? @platforms
+
+      build_configurations = project.build_configuration_list.build_configurations
+      build_configurations += project.targets.flat_map do |target|
+        target.build_configuration_list.build_configurations
+      end 
+
+      ps = build_configurations.flatten.each_with_object({}) do |configuration, sum|
+        bs = configuration.build_settings
+        d_t = []
+        d_t << :osx unless bs['MACOSX_DEPLOYMENT_TARGET'].nil?
+        d_t << :ios unless bs['IPHONEOS_DEPLOYMENT_TARGET'].nil?
+        d_t << :watchos unless bs['WATCHOS_DEPLOYMENT_TARGET'].nil?
+        d_t << :tvos unless bs['TVOS_DEPLOYMENT_TARGET'].nil?
+        sum[configuration.name] ||= []
+        sum[configuration.name] += d_t unless d_t.empty?
+      end
+
+      @platforms = ps.flat_map do |key, value|
+        Platform.new_from_platforms(key, value.uniq)
+      end
+    end
+    
+    def targets
+      return @targets if defined?(@targets)
+
+      project_dir = project.project_dir
+      
+      h_ts = project.targets.map do |target|
+        next if target.is_a?(Constants::PBXAggregateTarget)
+        
+        name = target.name
+        headers = target.build_phases.flat_map do |phase|
+          next unless phase.is_a?(Constants::PBXHeadersBuildPhase)
+
+          phase.files.flat_map do |file|
+            ff = file.file_ref
+            f_path = ff.instance_variable_get('@simple_attributes_hash')['path'] || ''
+            g_path = PBXHelper.group_paths(ff)
+            header_entry(project_dir, g_path, f_path, file)
+          end
+        end.compact
+        Target.new(headers, target, self)
+      end.compact
+      @targets = h_ts || []
+    end
+
+    def write_hmapfile!
+      hmap_writer = BuildSettingsWriter.new(platforms, context)
+      types = %i[all_non_framework_target_headers project_headers all_target_headers all_product_headers]
+      datas = headers_hash(*types)
+      hmap_writer.write_or_symlink(nil, datas, %i[all_product_headers])
+      targets.each(&:write_hmapfile!)
+    end
+
+    def save_hmap_settings!
+      targets.each(&:save_hmap_settings!)
+    end
+
+    def remove_hmap_settings!
+      targets.each(&:remove_hmap_settings!)
+    end
+
+    private
+
+    def header_entry(project_dir, group, file, xc)
+      settings_h = xc.instance_variable_get('@simple_attributes_hash') || {}
+      settings = settings_h['settings'] || {}
+      attributes = settings['ATTRIBUTES']
+      full_path = File.expand_path(File.join(project_dir, group, file))
+      extra_headers = []
+      extra_headers << File.join(group, file)
+      extra_headers << File.join(file)
+      extra_headers.uniq!
+      types = %i[Public Private Project]
+      attributes = 'Project' if attributes.nil?
+      ts = types.select { |type| attributes.include?(type.to_s) }
+      ts.map { |t| HeaderEntry.new(full_path, extra_headers, t) }
+    end
+
+    def entrys
+      return @entrys if defined?(@entrys)
+
+      project_dir = project.project_dir
+      @entrys = project.objects_by_uuid.flat_map do |_uuid, ff|
+        next unless ff.is_a?(Constants::PBXFileReference)
+
+        f_path = ff.instance_variable_get('@simple_attributes_hash')['path'] || ''
+        next unless HEADER_FILES_EXTENSIONS.include?(File.extname(f_path))
+
+        builds = ff.referrers.select { |e| e.is_a?(Constants::PBXBuildFile) } || []
+        g_path = PBXHelper.group_paths(ff)
+        if builds.empty?
+          header_entry(project_dir, g_path, f_path, nil)
+        else
+          builds.flat_map { |bf| header_entry(project_dir, g_path, f_path, bf) }
+        end
+      end.compact
+    end
+  end
+end