cocoapods-mapfile 0.2.2 → 0.2.3

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
+      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

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

@@ -0,0 +1,92 @@
+require 'hmap/xc/header_type'
+require 'hmap/xc/context'
+
+module HMap
+  class Project
+    module Helper
+      include HMap::HeaderType
+
+      define_method(:all_product_headers) do
+        return @all_product_headers if defined? @all_product_headers
+
+        @all_product_headers = targets.each_with_object({}) do |target, sum|
+          next if target.all_product_headers.nil?
+
+          sum.merge!(target.all_product_headers) { |_, oldval, newval| newval + oldval }
+        end
+      end
+
+      define_method(:all_non_framework_target_headers) do
+        return @all_non_framework_target_headers if defined?(@all_non_framework_target_headers)
+
+        @all_non_framework_target_headers = targets.flat_map(&:all_non_framework_target_headers).compact
+      end
+
+      # all_targets include header full module path
+      define_method(:all_target_headers) do
+        return @all_target_headers if defined?(@all_target_headers)
+
+        @all_target_headers = workspace.all_target_headers
+      end
+
+      define_method(:project_headers) do
+        return @project_headers if defined?(@project_headers)
+
+        @project_headers = all_target_headers + project_entrys.flat_map { |entry| entry.project_buckets_extra }
+      end
+
+      def project_references
+        return @project_references if defined? @project_references
+  
+        project_references = PBXHelper.project_references(project)
+        @project_references = project_references.map { |pr| Project.new(pr, workspace) }
+      end
+
+      def temp_name
+        "#{project_name}.build"
+      end
+
+      def build_dir() end
+
+      def project_name
+        project.root_object.name
+      end
+
+      def project_dir
+        project.project_dir
+      end
+
+      def temp_name
+        "#{project_name}.build"
+      end
+
+      def temp_root
+        File.join(workspace.obj_root, temp_name)
+      end
+
+      def build_root
+        workspace.build_root
+      end
+
+      def temp_dir
+        workspace.obj_root
+      end
+
+      def hmap_root
+        File.join(workspace.hmap_root, temp_name)
+      end
+
+      def build_data_dir
+        Constants::XCBuildData
+      end
+
+      def context
+        HMap::Context.new(build_root,
+                          temp_dir,
+                          File.join(hmap_root, build_data_dir),
+                          '',
+                          build_dir)
+      end
+    end
+  end
+end