cocoapods-mapfile 0.2.2 → 0.2.3

data/lib/hmap/{hmap_reader.rb → hmap/hmap_reader.rb}

@@ -1,23 +1,7 @@
 # frozen_string_literal: true
+require 'hmap/hmap/hmap_struct'
 
 module HMap
-  # hmap bucket
-  class HMapBucketStr
-    attr_reader :key, :perfix, :suffix
-
-    def initialize(key, perfix, suffix)
-      @key = key
-      @perfix = perfix
-      @suffix = suffix
-    end
-
-    def description
-      <<-DESC
-        Key #{@key} -> Prefix #{@perfix}, Suffix #{@suffix}
-      DESC
-    end
-  end
-
   # hmap file reader
   class MapFileReader
     # @return [String, nil] the filename loaded from, or nil if loaded from a binary
@@ -32,7 +16,7 @@ module HMap
     # @return [HMap::HMapHeader]
     attr_reader :header
 
-    # @return [Hash<HMap::HMapBucket => HMap::HMapBucketStr>] an array of the file's bucktes
+    # @return [Hash<HMap::HMapBucket => HMap::BucketStr>] an array of the file's bucktes
     # @note bucktes are provided in order of ascending offset.
     attr_reader :bucktes
 
@@ -55,7 +39,7 @@ module HMap
         bucket_s = bucket.to_a.map do |key|
           string_t[key..-1].match(/[^\0]+/)[0]
         end
-        HMapBucketStr.new(*bucket_s)
+        BucketStr.new(*bucket_s)
       end
     end
 
@@ -102,7 +86,7 @@ module HMap
 
     # description
     def description
-      sum = "  Header map: #{filename}\n" + header.description
+      sum = "  Header map path: #{filename}\n" + header.description
       bucktes.each_with_index do |buckte_h, index|
         sum += "\t- Bucket: #{index}" + Utils.safe_encode(buckte_h.values[0].description, 'UTF-8') unless buckte_h.nil?
         sum

data/lib/hmap/{hmap_saver.rb → hmap/hmap_saver.rb}

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'hmap/hmap/hmap_struct'
+require 'hmap/hmap/mapfile'
+
 module HMap
   class HMapSaver
     attr_reader :string_table, :buckets, :headers
@@ -19,7 +22,7 @@ module HMap
     def header_to_hash(keys, headers, index, buckets)
       index = index.length
       keys.inject('') do |sum, bucket|
-        buckte = HMapBucketStr.new(*bucket)
+        buckte = BucketStr.new(*bucket)
         string_t = buckte.bucket_to_string(headers, index + sum.length)
         buckets.push(buckte)
         sum + string_t
@@ -38,10 +41,12 @@ module HMap
       headers[key]
     end
 
-    def add_to_bucket(buckets)
-      values = buckets.map { |key| add_to_headers(key) }
-      bucket = HMapBucket.new(*values)
-      bucket.uuid = Utils.string_downcase_hash(buckets.first)
+    def add_to_bucket(buckte)
+      key = add_to_headers(buckte.key)
+      perfix = add_to_headers(buckte.perfix)
+      suffix = add_to_headers(buckte.suffix)
+      bucket = HMapBucket.new(key, perfix, suffix)
+      bucket.uuid = Utils.string_downcase_hash(buckte.key)
       @buckets << bucket
     end
 
@@ -50,7 +55,7 @@ module HMap
     end
 
     def write_to(path)
-      MapFile.new(@string_table, @buckets).write(path)
+      MapFile.new(@string_table, @buckets).write(Pathname(path))
     end
   end
 end

data/lib/hmap/hmap/hmap_writer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'hmap/xc/workspace/workspace'
+
+module HMap
+  class HMapTarget
+    attr_reader :name, :target
+  end
+
+  # 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(use_origin, project_root, clean_hmap)
+      UserInterface.puts("[hmapfile] Workspace/project root: #{project_root}..............")
+      UserInterface.puts("[hmapfile] Analyzing dependencies..............")
+      Resolver.instance.installation_root = project_root
+      Resolver.instance.use_origin = use_origin
+      create_hmapfile(clean_hmap)
+    end
+
+    # Integrates the projects mapfile associated
+    # with the App project and Pods project.
+    #
+    # @param  [clean] clean hmap dir @see #podfile
+    # @return [void]
+    #
+    def create_hmapfile(clean)
+      # {a,b}– Match pattern a or b.
+      # Though this looks like a regular expression quantifier, it isn't.
+      # For example, in regular expression, the pattern a{1,2} will match 1 or 2 'a' characters.
+      # In globbing, it will match the string a1 or a2.
+      paths = Dir.glob(File.join(Resolver.instance.installation_root, '*.{xcworkspace,xcodeproj}'))
+      workspace_paths = paths.select { |f| File.extname(f) == '.xcworkspace' }
+      xcs = if workspace_paths.nil?
+              project_paths = paths.select { |f| File.extname(f) == '.xcodeproj' }
+              Workspace.new_from_xcprojects(project_paths) unless project_paths.nil?
+            else
+              Workspace.new_from_xcworkspaces(workspace_paths)
+            end
+      xcs.each do |xc|
+        if clean
+          xc.remove_hmap_settings!
+        else
+          xc.write_save!
+        end
+      end
+    end
+  end
+end

data/lib/hmap/{mapfile.rb → hmap/mapfile.rb}

@@ -6,7 +6,7 @@ module HMap
     # @return mapfile string_table
     attr_reader :string_table
 
-    # @return [Array<HMap::HMapBucketStr>] an array of the file's bucktes
+    # @return [Array<HMap::BucketStr>] an array of the file's bucktes
     # @note bucktes are provided in order of ascending offset.
     attr_reader :buckets
 

data/lib/hmap/user_interface.rb

@@ -0,0 +1,22 @@
+module HMap
+    # Manages the UI output so clients can customize it.
+    #
+    module UserInterface
+      # Prints a message to standard output.
+      #
+      # @return [void]
+      #
+      def self.puts(message)
+        STDOUT.puts message
+      end
+  
+      # Prints a message to standard error.
+      #
+      # @return [void]
+      #
+      def self.warn(message)
+        STDERR.puts message
+      end
+    end
+    UI = UserInterface
+  end

data/lib/hmap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HMap
-  VERSION = '0.2.2'
+  VERSION = '0.2.3'
 end

data/lib/hmap/xc/context.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module HMap
+  class Context
+    attr_reader :build_root, :hmap_root, :temp_name, :build_dir, :temp_dir
+
+    def initialize(build_root, temp_dir, hmap_root, temp_name, build_dir)
+      @build_root = build_root
+      @temp_dir = temp_dir
+      @hmap_root = hmap_root
+      @temp_name = temp_name
+      @build_dir = build_dir || ''
+    end
+
+    def build_path(platform)
+      File.join(build_root, platform.to_s, build_dir)
+    end
+
+    def temp_path(platform)
+      File.join(temp_dir, platform.to_s, temp_name)
+    end
+  end
+end

data/lib/hmap/xc/header_entry.rb

@@ -0,0 +1,55 @@
+module HMap
+  class HeaderEntry
+    attr_reader :path, :extra_keys, :type
+
+    def initialize(path, extra_keys, type)
+      @path = path
+      @extra_keys = extra_keys
+      @type = type
+    end
+
+    def project_buckets
+      h_name = File.basename(path)
+      h_dir = File.dirname(path)
+      [BucketStr.new(h_name, "#{h_dir}/", h_name)]
+    end
+
+    def module_buckets(moudle_name)
+      h_name = File.basename(path)
+      module_p = "#{moudle_name}/"
+      [BucketStr.new(h_name, module_p, h_name)]
+    end
+
+    def full_module_buckets(moudle_name)
+      h_name = File.basename(path)
+      h_dir = File.dirname(path)
+      module_k = "#{moudle_name}/#{h_name}"
+      [BucketStr.new(module_k, "#{h_dir}/", h_name)]
+    end
+
+    def project_buckets_extra
+      h_name = File.basename(path)
+      h_dir = File.dirname(path)
+      buckets = []
+      buckets << BucketStr.new(h_name, "#{h_dir}/", h_name) unless extra_keys.include?(h_name)
+      buckets + extra_keys.map { |key| BucketStr.new(key, "#{h_dir}/", h_name) }
+    end
+
+    def module_buckets_extra(moudle_name)
+      h_name = File.basename(path)
+      module_p = "#{moudle_name}/"
+      buckets = []
+      buckets << BucketStr.new(h_name, module_p, h_name) unless extra_keys.include?(h_name)
+      buckets + extra_keys.map { |key| BucketStr.new(key, module_p, h_name) }
+    end
+
+    def full_module_buckets_extra(moudle_name)
+      h_name = File.basename(path)
+      h_dir = File.dirname(path)
+      module_k = "#{moudle_name}/#{h_name}"
+      buckets = []
+      buckets << BucketStr.new(module_k, "#{h_dir}/", h_name) unless extra_keys.include?(module_k)
+      buckets + extra_keys.map { |key| BucketStr.new(key, "#{h_dir}/", h_name) }
+    end
+  end
+end

data/lib/hmap/xc/header_type.rb

@@ -0,0 +1,32 @@
+
+require 'hmap/xc/header_entry'
+
+module HMap
+  module HeaderType
+    def public_entrys
+      return @public_entrys if defined?(@public_entrys)
+
+      @public_entrys = entrys.select { |entry| entry.type == :Public }
+    end
+
+    def private_entrys
+      return @private_entrys if defined?(@private_entrys)
+
+      @private_entrys = entrys.select { |entry| entry.type == :Private }
+    end
+
+    def project_entrys
+      return @project_entrys if defined?(@project_entrys)
+
+      @project_entrys = entrys.select { |entry| entry.type == :Project }
+    end
+
+    def use_vfs?
+      !public_entrys.empty? || !private_entrys.empty? || build_as_framework?
+    end
+
+    def headers_hash(*types)
+      Hash[types.map { |type| [type, send(type)] }]
+    end
+  end
+end

data/lib/hmap/xc/pbx_helper.rb

@@ -0,0 +1,68 @@
+module HMap
+  module PBXHelper
+    def self.get_groups(xct)
+      groups = xct.referrers.select { |e| e.is_a?(Constants::PBXGroup) } || []
+      groups += groups.flat_map { |g| get_groups(g) }
+      groups.compact.reverse
+    end
+
+    def self.group_paths(xct)
+      ps = get_groups(xct).map do |g|
+        s_hash = g.instance_variable_get('@simple_attributes_hash')
+        s_hash['path'] unless s_hash.nil?
+      end.compact
+      File.join(*ps)
+    end
+
+    def self.uses_swift?(target)
+      source_files = target.build_phases.flat_map do |phase|
+        phase.files if phase.is_a?(Constants::PBXSourcesBuildPhase)
+      end.compact
+      source_files.any? do |file|
+        path = file.file_ref.instance_variable_get('@simple_attributes_hash')['path'] || ''
+        File.extname(path) == '.swift'
+      end
+    end
+
+    def self.build_as_framework?(target)
+      target.symbol_type == :framework if target.respond_to?(:symbol_type)
+    end
+
+    def self.defines_module?(target)
+      return true if build_as_framework?(target)
+
+      bus = target.build_configuration_list.build_configurations.map do |bu|
+        bu.instance_variable_get('@simple_attributes_hash')['buildSettings'] || {}
+      end
+
+      bus.any? { |s| s['DEFINES_MODULE'] == 'YES' }
+    end
+
+    def self.projects(*p_paths)
+      return if p_paths.empty?
+
+      p_paths.flat_map do |pj|
+        project = Xcodeproj::Project.open(pj)
+        p_path = File.dirname(project.path)
+        project.root_object.project_references.map do |sp|
+          ff = sp[:project_ref]
+          path = ff.instance_variable_get('@simple_attributes_hash')['path'] || ''
+          full_path = File.join(p_path, path)
+          Xcodeproj::Project.open(full_path)
+        end << project
+      end
+    end
+
+    def self.project_references(project)
+      return if project.nil?
+
+      p_path = File.dirname(project.path)
+      project.root_object.project_references.map do |sp|
+        ff = sp[:project_ref]
+        path = ff.instance_variable_get('@simple_attributes_hash')['path'] || ''
+        full_path = File.join(p_path, path)
+        Xcodeproj::Project.open(full_path)
+      end
+    end
+  end
+end

data/lib/hmap/xc/product_helper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require 'hmap/xc/resolver'
+module HMap
+  class ProductPath
+    attr_reader :path, :build_setting, :name
+
+    def initialize(path)
+      @path = path
+      raise ArgumentError, "#{path}: can not get build directory" if @build_setting.nil?
+    end
+
+    def build_root
+      Pathname(build_setting[Constants::BUILD_DIR])
+    end
+
+    def obj_root
+      Pathname(build_setting[Constants::OBJROOT])
+    end
+  end
+
+  class WorkspaceProductPath < ProductPath
+    def initialize(path)
+      @name = File.basename(path, '.xcworkspace')
+      @build_setting = Resolver.instance.workspace_build_settings(path)
+      super
+    end
+  end
+
+  class ProjectProductPath < ProductPath
+    def initialize(path)
+      @name = File.basename(path, '.xcodeproj')
+      @build_setting = Resolver.instance.project_build_settings(path)
+      super
+    end
+  end
+end

data/lib/hmap/xc/resolver.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'hmap/helper/executable'
+
+module HMap
+  class Resolver
+    # @return [Array<String>] The filenames that the Podfile can have ordered
+    #         by priority.
+    #
+    PODFILE_NAMES = [
+      'CocoaPods.podfile.yaml',
+      'CocoaPods.podfile',
+      'Podfile',
+      'Podfile.rb'
+    ].freeze
+
+    attr_accessor :use_origin
+
+    def self.instance
+      @instance ||= new
+    end
+
+    # Sets the current config instance. If set to nil the config will be
+    # recreated when needed.
+    #
+    # @param  [Config, Nil] the instance.
+    #
+    # @return [void]
+    #
+    class << self
+      attr_writer :instance
+    end
+
+    def workspace_build_settings(workspace)
+      workspace_dic = xcodebuild_list(workspace)['workspace']
+      schemes = workspace_dic['schemes'] || []
+      targets = xcodebuild_workspace(workspace, schemes[0]) || []
+      targets.first['buildSettings']
+    end
+
+    def project_build_settings(project_path)
+      targets = xcodebuild(project_path) || []
+      targets.first['buildSettings']
+    end
+
+    # @return [Pathname] the root of the workspace or project where is located.
+    #
+    def installation_root
+      @installation_root ||= begin
+        current_dir = Pathname.new(Dir.pwd.unicode_normalize)
+        current_path = current_dir
+        until current_path.root?
+          if podfile_path_in_dir(current_path)
+            installation_root = current_path
+            puts("[in #{current_path}]") unless current_path == current_dir
+            break
+          else
+            current_path = current_path.parent
+          end
+        end
+        installation_root || current_dir
+      end
+    end
+
+    attr_writer :installation_root
+    alias project_root installation_root
+
+    def verbose?
+      false
+    end
+
+    # @return [String] Executes xcodebuild list in the current working directory and
+    #         returns its output (both STDOUT and STDERR).
+    #
+    def xcodebuild_list(workspace)
+      command = %W[-workspace #{workspace}]
+      command += %w[-json -list]
+      results = Executable.execute_command('xcodebuild', command, false)
+      JSON.parse(results) unless results.nil?
+    end
+
+    # @return [hash] Executes xcodebuild -workspace -scheme in the current working directory and
+    #         returns its output (both STDOUT and STDERR).
+    #
+    def xcodebuild_workspace(workspace, scheme)
+      command = %W[-workspace #{workspace}]
+      command += %W[-scheme #{scheme}]
+      xcodebuild(command)
+    end
+
+    # @return [hash] Executes xcodebuild -project in the current working directory and
+    #         returns its output (both STDOUT and STDERR).
+    #
+    def xcodebuild_project(project)
+      command = %W[-project #{project}]
+      xcodebuild(command)
+    end
+
+    private
+
+    # Returns the path of the Podfile in the given dir if any exists.
+    #
+    # @param  [Pathname] dir
+    #         The directory where to look for the Podfile.
+    #
+    # @return [Pathname] The path of the Podfile.
+    # @return [Nil] If not Podfile was found in the given dir
+    #
+    def podfile_path_in_dir(dir)
+      PODFILE_NAMES.each do |filename|
+        candidate = dir + filename
+        return candidate if candidate.file?
+      end
+      nil
+    end
+
+    # @return [hash] Executes xcodebuild in the current working directory, get build settings and
+    #         returns its output as hash  (both STDOUT and STDERR).
+    #
+    def xcodebuild(command)
+      command += %w[-json -showBuildSettings]
+      results = Executable.execute_command('xcodebuild', command, false)
+      index = results.index(/"action"/m)
+      reg = results[index..-1]
+      reg = "[\n{\n#{reg}"
+      JSON.parse(reg) unless results.nil?
+    end
+  end
+end

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