cocoapods-mapfile 0.2.5 → 0.2.7.0

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

@@ -42,35 +42,38 @@ module HMap
     def xcconfig_paths
       return @xcconfig_paths if defined?(@xcconfig_paths)
 
-      @xcconfig_paths = target.build_configuration_list.build_configurations.flat_map do |configuration|
+      @xcconfig_paths = target.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)
+            path = File.expand_path(File.join(project.project_dir, s_path, x))
+            xc = XCConfig.new(path)
+            inc = xc.includes_paths
+            path if inc.empty? || project.workspace.xcconfig_paths.none? { |pa| inc.include?(pa) }
           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
+
+      # @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'] || ''
+      #       File.expand_path File.join(project.project_dir, s_path, x)
+      #     end
       #   end
-      # end
+      # end.compact
     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

@@ -16,29 +16,50 @@ module HMap
       define_method(:all_non_framework_target_headers) do
         return if build_as_framework?
 
+        return @all_non_framework_target_headers if defined? @all_non_framework_target_headers
+
         p_h = public_entrys + private_entrys
-        p_h.flat_map { |entry| entry.full_module_buckets(product_name) }
+        @all_non_framework_target_headers = 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
+        return @all_target_headers if defined? @all_target_headers
+
         p_h = public_entrys + private_entrys
-        p_h.flat_map do |entry|
-          entry.full_module_buckets_extra(product_name) + entry.module_buckets(product_name)
+        @all_target_headers = 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)
+        return @project_headers if defined? @project_headers
+
+        p_h = public_entrys + private_entrys
+        hs = p_h.inject({}) do |sum, entry|
+          sum.merge!(entry.module_buckets(product_name)) { |_, v1, _| v1 }
+        end
+        @project_headers = project_entrys.inject(hs) do |sum, entry|
+          sum.merge!(entry.project_buckets_extra) { |_, v1, _| v1 }
+        end
       end
 
       define_method(:own_target_headers) do
+        return @own_target_headers if defined? @own_target_headers
+
         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
+        @own_target_headers = 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
@@ -52,7 +73,10 @@ module HMap
       end
 
       def product_name
-        target.product_name.gsub(/[-]/, '_')
+        product_name = target.build_settings(target.build_configurations.first.name)['PRODUCT_NAME']
+        return target_name.gsub(/-/, '_') if product_name.nil? || product_name.include?('TARGET_NAME')
+
+        product_name
       end
 
       def full_product_name
@@ -70,13 +94,14 @@ module HMap
       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
+        b_d = xcconfig_paths.none? { |path| XCConfig.new(path).attributes[Constants::CONFIGURATION_BUILD_DIR].nil? }
         @build_dir = target_name if b_d
       end
 
+      def app_target?
+        Xcodeproj::Constants::PRODUCT_UTI_EXTENSIONS[target.symbol_type] == 'app'
+      end
+
       def build_as_framework?
         PBXHelper.build_as_framework?(target)
       end

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,295 @@
+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 [Array] The list of the configuration files included by this
+    #         configuration file (`#include "SomeConfig"`).
+    #
+    attr_accessor :includes_paths
+
+    # @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 = []
+      @include_attributes = {}
+      merge!(extract_hash(xcconfig_hash_or_file))
+      @includes_paths = @includes.map { |i| File.expand_path(i, @filepath.dirname) }
+    end
+
+    def inspect
+      to_hash.inspect
+    end
+
+    def ==(other)
+      other.attributes == attributes && other.includes_paths = @includes_paths
+    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)
+      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)
+        e = extract_include(uncommented_line)
+        if e.nil?
+          key, value = extract_key_value(uncommented_line)
+          next unless key
+          value.gsub!(INHERITED_REGEXP) { |m| hash.fetch(key, m) }
+          hash[key] = value
+        else
+          @includes.push normalized_xcconfig_path(e)
+        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