cocoapods-mapfile 0.2.2 → 0.2.3

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'hmap/xc/product_helper'
+require 'hmap/xc/workspace/project'
+require 'hmap/xc/pbx_helper'
+
+module HMap
+  class Workspace
+    attr_reader :save_setting, :projects
+
+    def self.new_from_xcworkspaces(paths)
+      paths.flat_map do |path|
+        xc = Xcodeproj::Workspace.new_from_xcworkspace(path)
+        schemes = xc.schemes.values.uniq || []
+        ss = WorkspaceProductPath.new(path)
+        projects = PBXHelper.projects(*schemes)
+        new(ss, projects)
+      end
+    end
+
+    def self.new_from_xcprojects(paths)
+      paths.map do |path|
+        ss = ProjectProductPath.new(path)
+        projects = PBXHelper.projects(path)
+        new(ss, projects)
+      end
+    end
+
+    def initialize(save_setting, projects)
+      @save_setting = save_setting
+      @projects = projects.map { |project| Project.new(project, self) }
+    end
+
+    def build_root
+      save_setting.build_root
+    end
+
+    def obj_root
+      save_setting.obj_root
+    end
+
+    def name
+      save_setting.name
+    end
+
+    def workspace_dir
+      File.dirname(save_setting.path)
+    end
+
+    def hmap_root
+      dir = build_root.dirname.dirname
+      File.join(dir, Constants::HMAP_DIR)
+    end
+
+    def write_save!
+      UserInterface.puts("[hmapfile] Got workspace/project build directory..............")
+      UserInterface.puts("[hmapfile] #{name} Build directory: #{hmap_root} ..............")
+      write_hmapfile!
+      save_hmap_settings!
+    end
+
+    def write_hmapfile!
+      UserInterface.puts('[hmapfile] Starting generate hmap file..............')
+      projects.each(&:write_hmapfile!)
+    end
+
+    def save_hmap_settings!
+      UserInterface.puts('[hmapfile] Saving hmap settings..............')
+
+      projects.each(&:save_hmap_settings!)
+    end
+
+    def remove_hmap_settings!
+      UserInterface.puts('[hmapfile] Cleanning hmap settings..............')
+      FileUtils.rm_rf(hmap_root) if Dir.exist?(hmap_root)
+      projects.each(&:remove_hmap_settings!)
+    end
+
+    def all_target_headers
+      @projects.flat_map(&:targets).flat_map(&:all_target_headers)
+    end
+  end
+end

data/lib/hmap.rb

@@ -1,22 +1,24 @@
 # frozen_string_literal: true
 
+require 'xcodeproj'
+
 # The primary namespace for cocoapods-hmap.
 module HMap
+  require 'pathname'
+  require 'claide'
+
   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'
+  require_relative 'hmap/user_interface'
 
+  # autoload registers a file path to be loaded the first time
+  # that a specified module or class is accessed in the namespace of the calling module or class.
   autoload :Command, 'hmap/command'
-  autoload :MapFileReader, 'hmap/hmap_reader'
-  autoload :MapFileWriter, 'hmap/hmap_writer'
-  autoload :MapFile, 'hmap/mapfile'
-  autoload :Executable, 'hmap/executable'
+  autoload :Utils, 'hmap/helper/utils'
+  autoload :Constants, 'hmap/constants'
+  autoload :BucketStr, 'hmap/hmap/hmap_bucketstr'
+  autoload :HMapSaver, 'hmap/hmap/hmap_saver'
+  autoload :MapFileWriter, 'hmap/hmap/hmap_writer'
+  autoload :MapFileReader, 'hmap/hmap/hmap_reader'
+
+  # autoload :Struct, 'hmap/hmap/hmap_struct'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-mapfile
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Cat1237
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-23 00:00:00.000000000 Z
+date: 2021-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,33 +67,59 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: cocoapods
+  name: claide
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: 1.0.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: 1.0.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: xcodeproj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.19.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.19.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: yaml-vfs
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: 0.0.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: 0.0.4
 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:
@@ -112,21 +138,33 @@ files:
 - lib/hmap/command/hmap_gen.rb
 - lib/hmap/command/hmap_reader.rb
 - lib/hmap/command/hmap_writer.rb
+- lib/hmap/constants.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/executable.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/hmap/hmap_bucketstr.rb
+- lib/hmap/hmap/hmap_reader.rb
+- lib/hmap/hmap/hmap_saver.rb
+- lib/hmap/hmap/hmap_struct.rb
+- lib/hmap/hmap/hmap_writer.rb
+- lib/hmap/hmap/mapfile.rb
+- lib/hmap/user_interface.rb
 - lib/hmap/version.rb
+- lib/hmap/xc/context.rb
+- lib/hmap/xc/header_entry.rb
+- lib/hmap/xc/header_type.rb
+- lib/hmap/xc/pbx_helper.rb
+- lib/hmap/xc/product_helper.rb
+- lib/hmap/xc/resolver.rb
+- lib/hmap/xc/target/build_setting.rb
+- lib/hmap/xc/target/target.rb
+- lib/hmap/xc/target/target_context.rb
+- lib/hmap/xc/target/target_helper.rb
+- lib/hmap/xc/target/target_vfs.rb
+- lib/hmap/xc/target/xcconfig_helper.rb
+- lib/hmap/xc/workspace/project.rb
+- lib/hmap/xc/workspace/project_helper.rb
+- lib/hmap/xc/workspace/workspace.rb
 homepage: https://github.com/Cat1237/cocoapods-hmap.git
 licenses:
 - MIT
@@ -146,7 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Read or write header map file.

data/lib/hmap/framework/framework_vfs.rb

@@ -1,94 +0,0 @@
-require 'yaml_vfs'
-
-module HMap
-  module Target
-    # Each fremaework vfs informations
-    class FrameworkEntry
-      attr_reader :configuration, :platform, :app_build_dir, :project_temp_dir
-      attr_accessor :headers_real_paths, :modules_real_paths
-
-      def initialize(configuration, platform, app_build_dir, project_temp_dir)
-        @configuration = configuration
-        @platform = platform
-        @app_build_dir = app_build_dir
-        @project_temp_dir = project_temp_dir
-        @headers_real_paths = []
-        @modules_real_paths = []
-      end
-
-      def framework_moduler_path
-        File.join(app_build_dir, 'Modules')
-      end
-
-      def self.new_from_configuration_platform(configuration, platform, name, framework_name)
-        dir = "#{configuration}-#{platform}"
-        app_build_dir = File.join(PodsSpecification.instance.app_build_dir, dir, name,
-                                  "#{framework_name}.framework")
-        project_temp_dir = File.join(PodsSpecification.instance.project_temp_dir, dir, "#{name}.build")
-        new(configuration, platform, app_build_dir, project_temp_dir)
-      end
-
-      def self.new_entrys_from_configurations_platforms(configurations, platforms, name, framework_name, module_path, headers)
-        effective_platforms = Utils.effective_platforms_names(platforms)
-        configurations.flat_map do |configuration|
-          effective_platforms.map do |platform|
-            entry = new_from_configuration_platform(configuration, platform, name, framework_name)
-            entry.add_headers_modules(module_path, framework_name, headers)
-            entry
-          end
-        end
-      end
-
-      def add_headers_modules(module_path, framework_name, headers)
-        has_private_module = module_path.glob('module*.modulemap').length > 1
-        e_headers = ->(path, *names) { names.inject(Pathname(path)) { |e, n| e.join(n) } }
-        @headers_real_paths += headers
-        @headers_real_paths << e_headers.call(app_build_dir, 'Headers', "#{framework_name}-Swift.h")
-        @modules_real_paths << e_headers.call(project_temp_dir, 'module.modulemap')
-        return unless has_private_module
-
-        @modules_real_paths << e_headers.call(entry.project_temp_dir, 'module.private.modulemap')
-      end
-    end
-
-    # A collection of Each FrameworkEntrys
-    class FrameworkVFS
-      attr_reader :entrys
-
-      def initialize(entrys = [])
-        @entrys = entrys
-      end
-
-      def vfs_path
-        return {} if entrys.empty?
-
-        entrys.each_with_object({}) do |entry, paths|
-          c = "#{entry.configuration}-#{entry.platform}"
-          paths[c] ||= []
-          paths[c] << entry
-        end
-      end
-
-      def vfs_path_by_platform_and_configuration(platform, config)
-        return vfs_path if platform.nil? && config.nil?
-
-        key = platform if config.nil?
-        key = config if platform.nil?
-        vfs_path.select { |k, _| k.include?(key) }
-      end
-
-      def write(path)
-        vfs_path.each do |key, values|
-          es = values.map do |value|
-            VFS::FileCollectorEntry.new(Pathname(value.app_build_dir), value.modules_real_paths,
-                                        value.headers_real_paths)
-          end
-          fc = VFS::FileCollector.new(es)
-          pa = path.join(key)
-          pa.mkpath unless pa.exist?
-          fc.write_mapping(pa)
-        end
-      end
-    end
-  end
-end

data/lib/hmap/helper/build_setting_constants.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module HMap
-  # A collection of build settings key.
-  module BuildSettingConstants
-    OTHER_CFLAGS = 'OTHER_CFLAGS'
-    OTHER_CPLUSPLUSFLAGS = 'OTHER_CPLUSPLUSFLAGS'
-    HEAD_SEARCH_PATHS = 'HEADER_SEARCH_PATHS'
-    USER_HEADER_SEARCH_PATHS = 'USER_HEADER_SEARCH_PATHS'
-    USE_HEADERMAP = 'USE_HEADERMAP'
-    INGERITED = '$(inherited)'
-  end
-end

data/lib/hmap/helper/hmap_helper.rb

@@ -1,212 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-module HMap
-  # HMap file information
-  class HMapHeaderEntry
-    attr_reader :type, :headers
-
-    def initialize(type)
-      @type = type
-      @headers = []
-    end
-
-    def add_header(header)
-      headers << header
-    end
-
-    def file_name(name)
-      name = 'hmap' if name.nil?
-      [name, '-', type, '.hmap'].join
-    end
-
-    def build_setting_key
-      case type
-      when :i_headers, :iextra_headers
-        yield('-I', :HEADER_SEARCH_PATHS) if block_given?
-      when :iquote_headers, :extra_headers
-        yield('-iquote', :USER_HEADER_SEARCH_PATHS) if block_given?
-      else
-        raise Informative, "Error: header type not expect#{type}"
-      end
-    end
-
-    def build_setting(path, name)
-      full_path = File.join(path, file_name(name))
-      build_setting_key do |key|
-        [key, "\"#{full_path}\""]
-      end
-    end
-
-    def build_setting_xcconfig(path, name)
-      full_path = File.join(path, file_name(name))
-      build_setting_key do |_, xc|
-        [xc, "\"#{full_path}\""]
-      end
-    end
-  end
-
-  # A collection of Each HMapHeaderEntry
-  class HMapHeaders
-    def initialize
-      @public_headers = HMapHeaderEntry.new(:i_headers)
-      @public_headers_e = HMapHeaderEntry.new(:iextra_headers)
-      @private_headers = HMapHeaderEntry.new(:iquote_headers)
-      @private_headers_e = HMapHeaderEntry.new(:extra_headers)
-      @unqi_headers = Set.new
-    end
-
-    def headers
-      public_headers + private_headers
-    end
-
-    def public_headers
-      [@public_headers, @public_headers_e]
-    end
-
-    def private_headers
-      [@private_headers, @private_headers_e]
-    end
-
-    def private_setting_for_reference(path, name)
-      headers_build_settings_for_reference(private_headers, path, name)
-    end
-
-    def public_setting_for_reference(path, name)
-      headers_build_settings_for_reference(public_headers, path, name)
-    end
-
-    def private_setting_for_options(path, name)
-      headers_build_settings_for_options(private_headers, path, name, ' ').join(' ')
-    end
-
-    def public_setting_for_options(path, name)
-      headers_build_settings_for_options(public_headers, path, name).join(' ')
-    end
-
-    def headers_build_settings_for_reference(headers, path, name)
-      headers.each_with_object({}) do |header, setting|
-        se = header.build_setting_xcconfig(path, name)
-        setting.merge!(Hash[*se]) { |_, oldval, newval| [oldval, newval].join(' ') }
-      end
-    end
-
-    def headers_build_settings_for_options(headers, path, name, key = '')
-      headers.each_with_object([]) do |header, setting|
-        setting << header.build_setting(path, name).join(key)
-      end
-    end
-
-    def add_headers(type, headers, module_name, headers_sandbox)
-      headers.each do |header|
-        next unless @unqi_headers.add?(header)
-
-        header_name = header.basename.to_s
-        header_dir = "#{header.dirname}/"
-        header_module_path = "#{module_name}/#{header_name}"
-        header_module_name = "#{module_name}/"
-        header_relative_path = header.relative_path_from(headers_sandbox).to_s
-        header_last_dir_name = "#{header.dirname.basename}/#{header_name}"
-        case type
-        when :private_header_files, :public_header_files
-          @public_headers.add_header([header_name, header_module_name, header_name]) if type == :public_header_files
-          @public_headers_e.add_header([header_module_path, header_dir, header_name])
-          @private_headers.add_header([header_name, header_module_name, header_name])
-          unless header_relative_path == header_module_path || header_relative_path == header_name
-            @private_headers_e.add_header([header_relative_path, header_dir, header_name])
-          end
-          unless header_last_dir_name == header_module_path
-            @private_headers_e.add_header([header_last_dir_name, header_dir, header_name])
-          end
-        when :source_files
-          @private_headers_e.add_header([header_name, header_dir, header_name])
-          @private_headers_e.add_header([header_last_dir_name, header_dir, header_name])
-          @private_headers_e.add_header([header_relative_path, header_dir, header_name])
-        end
-      end
-    end
-  end
-
-  # Gen hmap file and vfs file
-  class HMapHelper
-    attr_reader :i_headers, :iquote_headers, :directory, :framework_entrys, :headers
-
-    def initialize(directory)
-      puts "Current hmap files dir: #{directory}"
-      @directory = Pathname(directory)
-      @framework_entrys = []
-      @headers = HMapHeaders.new
-    end
-
-    def write_hmapfile(name = nil)
-      return if directory.nil?
-
-      @headers.headers.each do |entry|
-        path = directory.join(entry.file_name(name))
-        hmap_write_headers_to_path(path, entry.headers)
-      end
-    end
-
-    def write_vfsfiles(name = '')
-      return if framework_entrys.empty?
-
-      vfs_directory = directory.join(name).join('vfs')
-      puts "Current vfs files dir: #{vfs_directory}"
-      Target::FrameworkVFS.new(framework_entrys).write(vfs_directory)
-      puts 'vfs files write finish.'
-    end
-
-    def write_hmap_vfs_to_paths(hmap_name = nil, vfs_name = '')
-      write_vfsfiles(vfs_name)
-      write_hmapfile(hmap_name)
-    end
-
-    def add_framework_entry(configurations, platforms,
-                            name, framework_name, module_path, headers)
-      entry = Target::FrameworkEntry.new_entrys_from_configurations_platforms(configurations, platforms, name,
-                                                                              framework_name, module_path, headers)
-      @framework_entrys += entry
-    end
-
-    def header_mappings(headers, headers_sandbox, module_name, type)
-      @headers.add_headers(type, headers, module_name, headers_sandbox)
-    end
-
-    def xcconfig_header_setting(is_framework, path = nil, name = nil)
-      i_s = @headers.public_setting_for_options(path, name)
-      setting_values = [[BuildSettingConstants::INGERITED, i_s].join(' ')]
-      setting_values << xcconfig_vfs_setting(path) if is_framework
-      setting_values << @headers.private_setting_for_options(path, name)
-      setting_values.each_with_object({}) do |value, setting|
-        setting.merge!({
-                         BuildSettingConstants::OTHER_CFLAGS => value,
-                         BuildSettingConstants::OTHER_CPLUSPLUSFLAGS => value
-                       }) { |_, oldval, newval| [oldval, newval].join(' ') }
-      end
-    end
-
-    private
-
-    def xcconfig_vfs_setting(path)
-      path = directory if path.nil?
-      "-ivfsoverlay \"#{path}/vfs/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/all-product-headers.yaml\""
-    end
-
-    def i_headers_name(name)
-      directory.join("#{name}.hmap")
-    end
-
-    def iquote_headers_name
-      directory.join("#{name}-iquote.hmap")
-    end
-
-    def hmap_write_headers_to_path(path, headers)
-      return if headers.empty?
-
-      print "\t - Save hmap file to path: "
-      puts path.to_s.yellow
-      HMapSaver.new_from_buckets(headers).write_to(path)
-    end
-  end
-end

data/lib/hmap/helper/pods_helper.rb

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