cocoapods-mapfile 0.2.5 → 0.2.6.1

data/lib/hmap/xc/header_entry.rb

@@ -11,45 +11,48 @@ module HMap
     def project_buckets
       h_name = File.basename(path)
       h_dir = File.dirname(path)
-      [BucketStr.new(h_name, "#{h_dir}/", h_name)]
+      { 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)]
+      { 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)]
+      { 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) }
+      buckets = {}
+      buckets[h_name] = ["#{h_dir}/", h_name] unless extra_keys.include?(h_name)
+      extra_keys.each { |key| buckets[key] = ["#{h_dir}/", h_name] }
+      buckets
     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) }
+      buckets = {}
+      buckets[h_name] = [module_p, h_name] unless extra_keys.include?(h_name)
+      extra_keys.each { |key| buckets[key] = [module_p, h_name] }
+      buckets
     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) }
+      buckets = {}
+      buckets[module_k] = ["#{h_dir}/", h_name] unless extra_keys.include?(module_k)
+      extra_keys.each { |key| buckets[key] = ["#{h_dir}/", h_name] }
+      buckets
     end
   end
 end

data/lib/hmap/xc/pbx_helper.rb

@@ -1,15 +1,19 @@
 module HMap
   module PBXHelper
+    PBX_GROUP = '<group>'.freeze
+    PBX_SOURCE_ROOT = 'SOURCE_ROOT'.freeze
+    private_constant :PBX_GROUP, :PBX_SOURCE_ROOT
     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
+      groups.compact
     end
 
     def self.group_paths(xct)
-      ps = get_groups(xct).map do |g|
+      gs = get_groups(xct).reverse
+      ps = gs.map do |g|
         s_hash = g.instance_variable_get('@simple_attributes_hash')
-        s_hash['path'] unless s_hash.nil?
+        s_hash['path'] unless s_hash.nil? && s_hash['sourceTree'] == PBX_GROUP
       end.compact
       File.join(*ps)
     end
@@ -46,8 +50,10 @@ module HMap
         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)
+          f_hash = ff.instance_variable_get('@simple_attributes_hash')
+          g_path = PBXHelper.group_paths(ff) if f_hash['sourceTree'] == PBX_GROUP
+          path = f_hash['path'] || ''
+          full_path = File.join(p_path, g_path || '', path)
           Xcodeproj::Project.open(full_path)
         end << project
       end

data/lib/hmap/xc/resolver.rb

@@ -39,7 +39,7 @@ module HMap
     end
 
     def project_build_settings(project_path)
-      targets = xcodebuild(project_path) || []
+      targets = xcodebuild_project(project_path) || []
       targets.first['buildSettings']
     end
 
@@ -121,7 +121,7 @@ module HMap
       command += %w[-json -showBuildSettings]
       results = Executable.execute_command('xcodebuild', command, false)
       index = results.index(/"action"/m)
-      reg = results[index..-1]
+      reg = results[index..]
       reg = "[\n{\n#{reg}"
       JSON.parse(reg) unless results.nil?
     end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'hmap/xc/target/target_vfs'
 
 module HMap
@@ -63,13 +64,7 @@ module HMap
     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)
+      Utils.file_symlink_to(path, Pathname.new(hmap_filepath(need_platform)))
     end
 
     def write(data, need_platform)

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

@@ -28,7 +28,7 @@ module HMap
 
     def save_hmap_settings!
       xcconfig_paths.each do |path|
-        settings = Constants.instance.hmap_build_settings
+        settings = Constants.instance.hmap_build_settings(build_as_framework?)
         XcodeprojHelper.new(path).add_build_settings_and_save(settings, use_origin: Resolver.instance.use_origin)
       end
     end
@@ -45,6 +45,14 @@ module HMap
       @xcconfig_paths = target.build_configuration_list.build_configurations.flat_map do |configuration|
         if configuration.is_a?(Constants::XCBuildConfiguration)
           bcr = configuration.base_configuration_reference
+          # if bcr.nil?
+          #   ab_path = Pathname(project.project_dir + "hmap-#{target_name}.#{configuration.name}.xcconfig")
+          #   File.new(ab_path, 'w') unless ab_path.exist?
+          #   xc_ref = target.project.new_file(ab_path)
+          #   configuration.base_configuration_reference = xc_ref
+          #   target.project.save
+          #   ab_path
+          # else
           unless bcr.nil?
             s_path = PBXHelper.group_paths(bcr)
             x = bcr.instance_variable_get('@simple_attributes_hash')['path'] || ''
@@ -52,25 +60,6 @@ module HMap
           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

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 module HMap
-  class Target 
+  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
@@ -11,15 +12,15 @@ module HMap
         @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)

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

@@ -17,28 +17,41 @@ module HMap
         return if build_as_framework?
 
         p_h = public_entrys + private_entrys
-        p_h.flat_map { |entry| entry.full_module_buckets(product_name) }
+        p_h.inject({}) do |sum, entry|
+          sum.merge!(entry.full_module_buckets(product_name)) { |_, v1, _| v1 }
+        end
       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)
+        p_h.inject({}) do |sum, entry|
+          sum.merge!(entry.module_buckets(product_name)) { |_, v1, _| v1 }
+          sum.merge!(entry.full_module_buckets(product_name)) { |_, v1, _| v1 }
         end
       end
 
       define_method(:project_headers) do
-        all_target_headers + project_entrys.flat_map(&:project_buckets_extra)
+        p_h = public_entrys + private_entrys
+        hs = p_h.inject({}) do |sum, entry|
+          sum.merge!(entry.module_buckets(product_name)) { |_, v1, _| v1 }
+        end
+        project_entrys.inject(hs) do |sum, entry|
+          sum.merge!(entry.project_buckets_extra) { |_, v1, _| v1 }
+        end
       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)
+        hs = headers.inject({}) do |sum, entry|
+          sum.merge!(entry.module_buckets(product_name)) { |_, v1, _| v1 }
+        end
+        project_entrys.inject(hs) do |sum, entry|
+          sum.merge!(entry.project_buckets) { |_, v1, _| v1 }
+          sum.merge!(entry.full_module_buckets(product_name)) { |_, v1, _| v1 }
         end
       end
+
       def build_root
         project.build_root
       end
@@ -71,7 +84,7 @@ module HMap
         return @build_dir if defined?(@build_dir)
 
         b_d = xcconfig_paths.any? do |path|
-          xc = Xcodeproj::Config.new(path)
+          xc = XCConfig.new(path)
           !xc.attributes[Constants::CONFIGURATION_BUILD_DIR].nil?
         end
         @build_dir = target_name if b_d

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

@@ -59,7 +59,6 @@ module HMap
     end
   end
 
-
   # A collection of Each TargetVFSEntry
   class TargetVFS
     def initialize(public_headers, private_headers, platforms, setting)

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

@@ -0,0 +1,290 @@
+module HMap
+  # This class holds the data for a Xcode build settings file (xcconfig) and
+  # provides support for serialization.
+  #
+  class XCConfig
+    require 'set'
+
+    KEY_VALUE_PATTERN = /
+      (
+        [^=\[]+     # Any char, but not an assignment operator
+                    # or subscript (non-greedy)
+        (?:         # One or multiple conditional subscripts
+          \[
+          [^\]]*    # The subscript key
+          (?:
+            =       # The subscript comparison operator
+            [^\]]*  # The subscript value
+          )?
+          \]
+        )*
+      )
+      \s*           # Whitespaces after the key (needed because subscripts
+                    # always end with ']')
+      =             # The assignment operator
+      (.*)          # The value
+    /x
+    private_constant :KEY_VALUE_PATTERN
+
+    INHERITED = %w($(inherited) ${inherited}).freeze
+    private_constant :INHERITED
+
+    INHERITED_REGEXP = Regexp.union(INHERITED)
+    private_constant :INHERITED_REGEXP
+
+    # @return [Hash{String => String}] The attributes of the settings file
+    #         excluding frameworks, weak_framework and libraries.
+    #
+    attr_accessor :attributes
+
+    # @return [Hash{Symbol => Set<String>}] The other linker flags by key.
+    #         Xcodeproj handles them in a dedicated way to prevent duplication
+    #         of the libraries and of the frameworks.
+    #
+    def initialize(xcconfig_hash_or_file = {})
+      @attributes = {}
+      @includes = []
+      merge!(extract_hash(xcconfig_hash_or_file))
+    end
+
+    def inspect
+      to_hash.inspect
+    end
+
+    def ==(other)
+      other.attributes == attributes
+    end
+
+    # @!group Serialization
+    #-------------------------------------------------------------------------#
+
+    # Sorts the internal data by setting name and serializes it in the xcconfig
+    # format.
+    #
+    # @example
+    #
+    #   config = Config.new('PODS_ROOT' => '"$(SRCROOT)/Pods"', 'OTHER_LDFLAGS' => '-lxml2')
+    #   config.to_s # => "OTHER_LDFLAGS = -lxml2\nPODS_ROOT = \"$(SRCROOT)/Pods\""
+    #
+    # @return [String] The serialized internal data.
+    #
+    def to_s(prefix = nil)
+      include_lines = @includes.map { |path| "#include \"#{normalized_xcconfig_path(path)}\"" }
+      settings = to_hash(prefix).sort_by(&:first).map { |k, v| "#{k} = #{v}".strip }
+      (include_lines + settings).join("\n") << "\n"
+    end
+
+    # Writes the serialized representation of the internal data to the given
+    # path.
+    #
+    # @param  [Pathname] pathname
+    #         The file where the data should be written to.
+    #
+    # @return [void]
+    #
+    def save_as(pathname, prefix = nil)
+      return if File.exist?(pathname) && (XCConfig.new(pathname) == self)
+
+      pathname.open('w') { |file| file << to_s(prefix) }
+    end
+
+    # The hash representation of the xcconfig. The hash includes the
+    # frameworks, the weak frameworks, the libraries and the simple other
+    # linker flags in the `Other Linker Flags` (`OTHER_LDFLAGS`).
+    #
+    # @note   All the values are sorted to have a consistent output in Ruby
+    #         1.8.7.
+    #
+    # @return [Hash] The hash representation
+    #
+    def to_hash(prefix = nil)
+      list = []
+
+      result = attributes.dup
+      result.reject! { |_, v| INHERITED.any? { |i| i == v.to_s.strip } }
+      if prefix
+        Hash[result.map { |k, v| [prefix + k, v] }]
+      else
+        result
+      end
+    end
+
+    alias to_h to_hash
+
+    # @!group Merging
+    #-------------------------------------------------------------------------#
+
+    # Merges the given xcconfig representation in the receiver.
+    # @note   If a key in the given hash already exists in the internal data
+    #         then its value is appended.
+    #
+    # @param  [Hash, Config] config
+    #         The xcconfig representation to merge.
+    #
+    # @todo   The logic to normalize an hash should be extracted and the
+    #         initializer should not call this method.
+    #
+    # @return [void]
+    #
+    def merge!(xcconfig)
+      if xcconfig.is_a? XCConfig
+        merge_attributes!(xcconfig.attributes)
+      else
+        merge_attributes!(xcconfig.to_hash)
+      end
+    end
+    alias << merge!
+
+    # Creates a new #{Config} with the data of the receiver merged with the
+    # given xcconfig representation.
+    #
+    # @param  [Hash, Config] config
+    #         The xcconfig representation to merge.
+    #
+    # @return [Config] the new xcconfig.
+    #
+    def merge(config)
+      dup.tap { |x| x.merge!(config) }
+    end
+
+    # @return [Config] A copy of the receiver.
+    #
+    def dup
+      HMap::XCConfig.new(to_hash.dup)
+    end
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # @!group Private Helpers
+
+    # Returns a hash from the given argument reading it from disk if necessary.
+    #
+    # @param  [String, Pathname, Hash] argument
+    #         The source from where the hash should be extracted.
+    #
+    # @return [Hash]
+    #
+    def extract_hash(argument)
+      return argument if argument.is_a?(Hash)
+
+      if argument.respond_to? :read
+        @filepath = Pathname.new(argument.to_path)
+        hash_from_file_content(argument.read)
+      elsif File.readable?(argument.to_s)
+        @filepath = Pathname.new(argument.to_s)
+        hash_from_file_content(File.read(argument))
+      else
+        argument
+      end
+    end
+
+    # Returns a hash from the string representation of an Xcconfig file.
+    #
+    # @param  [String] string
+    #         The string representation of an xcconfig file.
+    #
+    # @return [Hash] the hash containing the xcconfig data.
+    #
+    def hash_from_file_content(string)
+      hash = {}
+      string.split("\n").each do |line|
+        uncommented_line = strip_comment(line)
+        if include = extract_include(uncommented_line)
+          @includes.push normalized_xcconfig_path(include)
+        else
+          key, value = extract_key_value(uncommented_line)
+          next unless key
+
+          value.gsub!(INHERITED_REGEXP) { |m| hash.fetch(key, m) }
+          hash[key] = value
+        end
+      end
+      hash
+    end
+
+    # Merges the given attributes hash while ensuring values are not duplicated.
+    #
+    # @param  [Hash] attributes
+    #         The attributes hash to merge into @attributes.
+    #
+    # @return [void]
+    #
+    def merge_attributes!(attributes)
+      @attributes.merge!(attributes) do |_, v1, v2|
+        v1 = v1.strip
+        v2 = v2.strip
+        v1_split = v1.shellsplit
+        v2_split = v2.shellsplit
+        if (v2_split - v1_split).empty? || v1_split.first(v2_split.size) == v2_split
+          v1
+        elsif v2_split.first(v1_split.size) == v1_split
+          v2
+        else
+          "#{v1} #{v2}"
+        end
+      end
+    end
+
+    # Strips the comments from a line of an xcconfig string.
+    #
+    # @param  [String] line
+    #         the line to process.
+    #
+    # @return [String] the uncommented line.
+    #
+    def strip_comment(line)
+      line.partition('//').first
+    end
+
+    # Returns the file included by a line of an xcconfig string if present.
+    #
+    # @param  [String] line
+    #         the line to process.
+    #
+    # @return [String] the included file.
+    # @return [Nil] if no include was found in the line.
+    #
+    def extract_include(line)
+      regexp = /#include\s*"(.+)"/
+      match = line.match(regexp)
+      match[1] if match
+    end
+
+    # Returns the key and the value described by the given line of an xcconfig.
+    #
+    # @param  [String] line
+    #         the line to process.
+    #
+    # @return [Array] A tuple where the first entry is the key and the second
+    #         entry is the value.
+    #
+    def extract_key_value(line)
+      match = line.match(KEY_VALUE_PATTERN)
+      if match
+        key = match[1]
+        value = match[2]
+        [key.strip, value.strip]
+      else
+        []
+      end
+    end
+
+    # Normalizes the given path to an xcconfing file to be used in includes,
+    # appending the extension if necessary.
+    #
+    # @param  [String] path
+    #         The path of the file which will be included in the xcconfig.
+    #
+    # @return [String] The normalized path.
+    #
+    def normalized_xcconfig_path(path)
+      if File.extname(path) == '.xcconfig'
+        path
+      else
+        "#{path}.xcconfig"
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'xcconfig'
+
 module HMap
   # A collection of xcodeproj Helper functions used throughout hmap.
   class XcodeprojHelper
@@ -12,12 +14,11 @@ module HMap
     def initialize(path)
       xc = Pathname(path)
       @xcconfig_path = xc
-      @xcconfig = Xcodeproj::Config.new(xc)
+      @xcconfig = XCConfig.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
@@ -40,7 +41,7 @@ module HMap
       else
         save_origin = save_build_setting(key)
         e_value = value
-        e_value = "#{e_value} ${#{save_xckey(key)}}" if use_origin && !save_origin.nil?
+        e_value = "${#{save_xckey(key)}} #{e_value} " if use_origin && !save_origin.nil?
         @xcconfig.attributes[hmap_xckey(key)] = e_value
         @xcconfig.attributes[key] = "${#{hmap_xckey(key)}}"
       end
@@ -61,10 +62,9 @@ module HMap
     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)
+        sum << key[HMAP_XCKEY_START.length..] if key.start_with?(HMAP_XCKEY_START)
+        sum << key[SAVE_XCKEY_START.length..] if key.start_with?(SAVE_XCKEY_START)
       end.compact
       remove_build_settings(hmap_ks)
       save_as
@@ -78,9 +78,7 @@ module HMap
     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.delete(setting) if save_origin.nil? && !origin.nil? && origin.include?(hmap_xckey(setting))
       @xcconfig.attributes[setting] = save_origin unless save_origin.nil?
       @xcconfig.attributes.delete(hmap_xckey(setting))
       @xcconfig.attributes.delete(save_xckey(setting))
@@ -97,7 +95,6 @@ module HMap
       !@xcconfig.attributes[key].nil?
     end
 
-
     def hmap_xckey(key)
       "#{HMAP_XCKEY_START}#{key}"
     end

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

@@ -22,7 +22,7 @@ module HMap
       build_configurations = project.build_configuration_list.build_configurations
       build_configurations += project.targets.flat_map do |target|
         target.build_configuration_list.build_configurations
-      end 
+      end
 
       ps = build_configurations.flatten.each_with_object({}) do |configuration, sum|
         bs = configuration.build_settings
@@ -39,16 +39,15 @@ module HMap
         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)
 
@@ -69,7 +68,11 @@ module HMap
       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!)
+      targets.each do |target|
+        target.write_hmapfile!
+        UserInterface.puts("[hmapfile] #{target.target_name} hmap files generated".green)
+      end
+      UserInterface.puts("[hmapfile] There are #{targets.length} targets hmap files generated")
     end
 
     def save_hmap_settings!