cocoapods 1.5.3 → 1.6.0.beta.1

data/lib/cocoapods/generator/xcconfig.rb

@@ -1,13 +0,0 @@
-module Pod
-  module Generator
-    # Generates Xcode configuration files. A configuration file is generated
-    # for each Pod and for each Pod target definition. The aggregates the
-    # configurations of the Pods and define target specific settings.
-    #
-    module XCConfig
-      autoload :AggregateXCConfig,  'cocoapods/generator/xcconfig/aggregate_xcconfig'
-      autoload :PodXCConfig,        'cocoapods/generator/xcconfig/pod_xcconfig'
-      autoload :XCConfigHelper,     'cocoapods/generator/xcconfig/xcconfig_helper'
-    end
-  end
-end

data/lib/cocoapods/generator/xcconfig/aggregate_xcconfig.rb

@@ -1,260 +0,0 @@
-module Pod
-  module Generator
-    module XCConfig
-      # Generates the xcconfigs for the aggregate targets.
-      #
-      class AggregateXCConfig
-        # @return [AggregateTarget] the target represented by this xcconfig.
-        #
-        attr_reader :target
-
-        # @return [String] the name of the build configuration to generate this
-        #         xcconfig for.
-        #
-        attr_reader :configuration_name
-
-        # Initialize a new instance
-        #
-        # @param  [Target] target @see target
-        #
-        # @param  [String] configuration_name @see configuration_name
-        #
-        def initialize(target, configuration_name)
-          @target = target
-          @configuration_name = configuration_name
-        end
-
-        # @return [Xcodeproj::Config] The generated xcconfig.
-        #
-        attr_reader :xcconfig
-
-        # Generates and saves the xcconfig to the given path.
-        #
-        # @param  [Pathname] path
-        #         the path where the xcconfig should be stored.
-        #
-        # @return [void]
-        #
-        def save_as(path)
-          generate.save_as(path)
-        end
-
-        # Generates the xcconfig.
-        #
-        # @note   The xcconfig file for a Pods integration target includes the
-        #         namespaced xcconfig files for each spec target dependency.
-        #         Each namespaced configuration value is merged into the Pod
-        #         xcconfig file.
-        #
-        # @todo   This doesn't include the specs xcconfigs anymore and now the
-        #         logic is duplicated.
-        #
-        # @return [Xcodeproj::Config]
-        #
-        def generate
-          includes_static_libs = !target.requires_frameworks?
-          includes_static_libs ||= pod_targets.flat_map(&:file_accessors).any? { |fa| !fa.vendored_static_artifacts.empty? }
-          config = {
-            'FRAMEWORK_SEARCH_PATHS' => '$(inherited) ',
-            'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) COCOAPODS=1',
-            'HEADER_SEARCH_PATHS' => '$(inherited) ',
-            'LIBRARY_SEARCH_PATHS' => '$(inherited) ',
-            'OTHER_CFLAGS' => '$(inherited) ',
-            'OTHER_LDFLAGS' => '$(inherited) ' + XCConfigHelper.default_ld_flags(target, includes_static_libs),
-            'OTHER_SWIFT_FLAGS' => '$(inherited) ',
-            'PODS_PODFILE_DIR_PATH' => target.podfile_dir_relative_path,
-            'PODS_ROOT' => target.relative_pods_root,
-            'SWIFT_INCLUDE_PATHS' => '$(inherited) ',
-          }.merge(embedded_content_settings)
-
-          @xcconfig = Xcodeproj::Config.new(config)
-
-          @xcconfig.merge!(merged_user_target_xcconfigs)
-
-          generate_settings_to_import_pod_targets
-
-          XCConfigHelper.add_target_specific_settings(target, @xcconfig)
-
-          targets = pod_targets + target.search_paths_aggregate_targets.flat_map(&:pod_targets)
-          XCConfigHelper.generate_vendored_build_settings(target, targets, @xcconfig)
-          XCConfigHelper.generate_other_ld_flags(target, pod_targets, @xcconfig)
-
-          # TODO: Need to decide how we are going to ensure settings like these
-          # are always excluded from the user's project.
-          #
-          # See https://github.com/CocoaPods/CocoaPods/issues/1216
-          @xcconfig.attributes.delete('USE_HEADERMAP')
-
-          # If any of the aggregate target dependencies bring in any vendored dynamic artifacts we should ensure to
-          # update the runpath search paths.
-          vendored_dynamic_artifacts = pod_targets.flat_map(&:file_accessors).flat_map(&:vendored_dynamic_artifacts)
-
-          symbol_type = target.user_targets.map(&:symbol_type).uniq.first
-          test_bundle = symbol_type == :octest_bundle || symbol_type == :unit_test_bundle || symbol_type == :ui_test_bundle
-          XCConfigHelper.generate_ld_runpath_search_paths(target, target.requires_host_target?, test_bundle, @xcconfig) if target.requires_frameworks? || vendored_dynamic_artifacts.count > 0
-
-          @xcconfig
-        end
-
-        #---------------------------------------------------------------------#
-
-        protected
-
-        # @return String the SWIFT_VERSION of the target being integrated
-        #
-        def target_swift_version
-          target.target_definition.swift_version unless target.target_definition.swift_version.blank?
-        end
-
-        EMBED_STANDARD_LIBRARIES_MINIMUM_VERSION = Version.new('2.3')
-
-        # @return [Hash<String, String>] the build settings necessary for Swift
-        #  targets to be correctly embedded in their host.
-        #
-        def embedded_content_settings
-          # For embedded targets, which live in a host target, CocoaPods
-          # copies all of the embedded target's pod_targets its host
-          # target. Therefore, this check will properly require the Swift
-          # libs in the host target, if the embedded target has any pod targets
-          # that use Swift. Setting this for the embedded target would
-          # cause an App Store rejection because frameworks cannot be embedded
-          # in embedded targets.
-
-          swift_version = Version.new(target_swift_version)
-          should_embed = !target.requires_host_target? && pod_targets.any?(&:uses_swift?)
-          config = {}
-          if should_embed
-            if swift_version >= EMBED_STANDARD_LIBRARIES_MINIMUM_VERSION
-              config['ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES'] = 'YES'
-            else
-              config['EMBEDDED_CONTENT_CONTAINS_SWIFT'] = 'YES'
-            end
-          end
-          config
-        end
-
-        # @return [Hash<String, String>] the build settings necessary to import
-        #         the pod targets.
-        #
-        def settings_to_import_pod_targets
-          if target.requires_frameworks?
-            build_pod_targets = pod_targets.select(&:should_build?)
-            framework_header_search_paths = build_pod_targets.map do |target|
-              "#{target.build_product_path}/Headers"
-            end
-            build_settings = {
-              # TODO: remove quote imports in CocoaPods 2.0
-              # Make framework headers discoverable by `import "…"`
-              'OTHER_CFLAGS' => XCConfigHelper.quote(framework_header_search_paths, '-iquote'),
-            }
-            if pod_targets.any? { |t| !t.should_build? }
-              # Make library headers discoverable by `#import "…"`
-              library_header_search_paths = target.sandbox.public_headers.search_paths(target.platform)
-              # TODO: remove quote imports in CocoaPods 2.0
-              build_settings['HEADER_SEARCH_PATHS'] = XCConfigHelper.quote(library_header_search_paths)
-              build_settings['OTHER_CFLAGS'] += ' ' + XCConfigHelper.quote(library_header_search_paths, '-isystem')
-            end
-            build_settings
-          else
-            # Make headers discoverable from $PODS_ROOT/Headers directory
-            header_search_paths = target.sandbox.public_headers.search_paths(target.platform)
-            {
-              # TODO: remove quote imports in CocoaPods 2.0
-              # by `#import "…"`
-              'HEADER_SEARCH_PATHS' => XCConfigHelper.quote(header_search_paths),
-              # by `#import <…>`
-              'OTHER_CFLAGS' => XCConfigHelper.quote(header_search_paths, '-isystem'),
-            }
-          end
-        end
-
-        private
-
-        # Add build settings, which ensure that the pod targets can be imported from the integrating target.
-        # For >= 1.5.0 we use modular (stricter) header search paths this means that the integrated target will only be
-        # able to import public headers using `<>` or `@import` notation, but never import any private headers.
-        #
-        # For < 1.5.0 legacy header search paths the same rules apply: It's the wild west.
-        #
-        def generate_settings_to_import_pod_targets
-          @xcconfig.merge! XCConfigHelper.search_paths_for_dependent_targets(target, pod_targets)
-          @xcconfig.merge!(settings_to_import_pod_targets)
-          target.search_paths_aggregate_targets.each do |search_paths_target|
-            generator = AggregateXCConfig.new(search_paths_target, configuration_name)
-            @xcconfig.merge! XCConfigHelper.search_paths_for_dependent_targets(nil, search_paths_target.pod_targets)
-            @xcconfig.merge!(generator.settings_to_import_pod_targets)
-            # Propagate any HEADER_SEARCH_PATHS settings from the search paths.
-            XCConfigHelper.propagate_header_search_paths_from_search_paths(search_paths_target, @xcconfig)
-          end
-        end
-
-        private
-
-        #---------------------------------------------------------------------#
-
-        # !@group Private Helpers
-
-        # Returns the {PodTarget}s which are active for the current
-        # configuration name.
-        #
-        # @return [Array<PodTarget>]
-        #
-        def pod_targets
-          target.pod_targets_for_build_configuration(configuration_name)
-        end
-
-        # Returns the +user_target_xcconfig+ for all pod targets and their spec
-        # consumers grouped by keys
-        #
-        # @return [Hash{String,Hash{Target,String}]
-        #
-        def user_target_xcconfig_values_by_consumer_by_key
-          pod_targets.each_with_object({}) do |target, hash|
-            target.spec_consumers.each do |spec_consumer|
-              spec_consumer.user_target_xcconfig.each do |k, v|
-                (hash[k] ||= {})[spec_consumer] = v
-              end
-            end
-          end
-        end
-
-        # Merges the +user_target_xcconfig+ for all pod targets into the
-        # #xcconfig and warns on conflicting definitions.
-        #
-        # @return [Hash{String, String}]
-        #
-        def merged_user_target_xcconfigs
-          settings = user_target_xcconfig_values_by_consumer_by_key
-          settings.each_with_object({}) do |(key, values_by_consumer), xcconfig|
-            uniq_values = values_by_consumer.values.uniq
-            values_are_bools = uniq_values.all? { |v| v =~ /^(yes|no)$/i }
-            if values_are_bools
-              # Boolean build settings
-              if uniq_values.count > 1
-                UI.warn 'Can\'t merge user_target_xcconfig for pod targets: ' \
-                  "#{values_by_consumer.keys.map(&:name)}. Boolean build "\
-                  "setting #{key} has different values."
-              else
-                xcconfig[key] = uniq_values.first
-              end
-            elsif key =~ /S$/
-              # Plural build settings
-              xcconfig[key] = uniq_values.join(' ')
-            else
-              # Singular build settings
-              if uniq_values.count > 1
-                UI.warn 'Can\'t merge user_target_xcconfig for pod targets: ' \
-                  "#{values_by_consumer.keys.map(&:name)}. Singular build "\
-                  "setting #{key} has different values."
-              else
-                xcconfig[key] = uniq_values.first
-              end
-            end
-          end
-        end
-
-        #---------------------------------------------------------------------#
-      end
-    end
-  end
-end

data/lib/cocoapods/generator/xcconfig/pod_xcconfig.rb

@@ -1,87 +0,0 @@
-module Pod
-  module Generator
-    module XCConfig
-      # Generates the private xcconfigs for the pod targets.
-      #
-      # The xcconfig file for a Pod target merges the pod target
-      # configuration values with the default configuration values
-      # required by CocoaPods.
-      #
-      class PodXCConfig
-        # @return [Target] the target represented by this xcconfig.
-        #
-        attr_reader :target
-
-        # Initialize a new instance
-        #
-        # @param  [Target] target @see target
-        #
-        # @param  [Boolean] test_xcconfig
-        #         whether this is an xcconfig for a test native target.
-        #
-        def initialize(target, test_xcconfig = false)
-          @target = target
-          @test_xcconfig = test_xcconfig
-        end
-
-        # @return [Xcodeproj::Config] The generated xcconfig.
-        #
-        attr_reader :xcconfig
-
-        # Generates and saves the xcconfig to the given path.
-        #
-        # @param  [Pathname] path
-        #         the path where the prefix header should be stored.
-        #
-        # @return [void]
-        #
-        def save_as(path)
-          generate.save_as(path)
-        end
-
-        # Generates the xcconfig.
-        #
-        # @return [Xcodeproj::Config]
-        #
-        def generate
-          config = {
-            'FRAMEWORK_SEARCH_PATHS' => '$(inherited) ',
-            'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) COCOAPODS=1',
-            'HEADER_SEARCH_PATHS' => '$(inherited) ' + XCConfigHelper.quote(target.header_search_paths(@test_xcconfig)),
-            'LIBRARY_SEARCH_PATHS' => '$(inherited) ',
-            'OTHER_CFLAGS' => '$(inherited) ',
-            'OTHER_LDFLAGS' => XCConfigHelper.default_ld_flags(target, @test_xcconfig),
-            'OTHER_SWIFT_FLAGS' => '$(inherited) ',
-            'PODS_ROOT' => '${SRCROOT}',
-            'PODS_TARGET_SRCROOT' => target.pod_target_srcroot,
-            'PRODUCT_BUNDLE_IDENTIFIER' => 'org.cocoapods.${PRODUCT_NAME:rfc1034identifier}',
-            'SKIP_INSTALL' => 'YES',
-            'SWIFT_ACTIVE_COMPILATION_CONDITIONS' => '$(inherited) ',
-            'SWIFT_INCLUDE_PATHS' => '$(inherited) ',
-          }
-
-          @xcconfig = Xcodeproj::Config.new(config)
-
-          XCConfigHelper.add_settings_for_file_accessors_of_target(nil, target, @xcconfig, true, @test_xcconfig)
-          target.file_accessors.each do |file_accessor|
-            @xcconfig.merge!(file_accessor.spec_consumer.pod_target_xcconfig) if @test_xcconfig == file_accessor.spec.test_specification?
-          end
-          XCConfigHelper.add_target_specific_settings(target, @xcconfig)
-          recursive_dependent_targets = target.recursive_dependent_targets
-          @xcconfig.merge! XCConfigHelper.search_paths_for_dependent_targets(target, recursive_dependent_targets, @test_xcconfig)
-          XCConfigHelper.generate_vendored_build_settings(target, recursive_dependent_targets, @xcconfig, false, @test_xcconfig)
-          if @test_xcconfig
-            test_dependent_targets = [target, *target.recursive_test_dependent_targets].uniq
-            @xcconfig.merge! XCConfigHelper.search_paths_for_dependent_targets(target, test_dependent_targets - recursive_dependent_targets, @test_xcconfig)
-            XCConfigHelper.generate_vendored_build_settings(nil, target.all_dependent_targets, @xcconfig, true, @test_xcconfig)
-            XCConfigHelper.generate_other_ld_flags(nil, target.all_dependent_targets, @xcconfig)
-            XCConfigHelper.generate_ld_runpath_search_paths(target, false, true, @xcconfig)
-          end
-          @xcconfig
-        end
-
-        #-----------------------------------------------------------------------#
-      end
-    end
-  end
-end

data/lib/cocoapods/generator/xcconfig/xcconfig_helper.rb

@@ -1,558 +0,0 @@
-require 'active_support/core_ext/object/try'
-
-module Pod
-  module Generator
-    module XCConfig
-      # Stores the shared logic of the classes of the XCConfig module.
-      #
-      module XCConfigHelper
-        # @return [String] Used as alias for BUILD_DIR, so that when this
-        #         is overridden in the user target, the user can override
-        #         this variable to point to the standard directory, which
-        #         will be used by CocoaPods.
-        #
-        BUILD_DIR_VARIABLE = '${PODS_BUILD_DIR}'.freeze
-
-        # @return [String] Used as alias for CONFIGURATION_BUILD_DIR, so that
-        #         when this is overridden per {PodTarget}, it is still possible
-        #         to reference other build products relative to the original
-        #         path. Furthermore if it was overridden in the user target,
-        #         the user can override this variable to point to the standard
-        #         directory, which will be used by CocoaPods.
-        #
-        CONFIGURATION_BUILD_DIR_VARIABLE = '${PODS_CONFIGURATION_BUILD_DIR}'.freeze
-
-        # Converts an array of strings to a single string where the each string
-        # is surrounded by double quotes and separated by a space. Used to
-        # represent strings in a xcconfig file.
-        #
-        # @param  [Array<String>] strings
-        #         a list of strings.
-        #
-        # @param  [String] prefix
-        #         optional prefix, such as a flag or option.
-        #
-        # @return [String] the resulting string.
-        #
-        def self.quote(strings, prefix = nil)
-          prefix = "#{prefix} " if prefix
-          strings.sort.map { |s| %W( #{prefix}"#{s}"          ) }.join(' ')
-        end
-
-        # Return the default linker flags
-        #
-        # @param  [Target] target
-        #         the target, which is used to check if the ARC compatibility
-        #         flag is required.
-        #
-        # @param  [Boolean] include_objc_flag
-        #         whether to include `-ObjC` in the other linker flags
-        #
-        # @return [String] the default linker flags. `-ObjC` is optionally included depending
-        #         on the target while `-fobjc-arc` is included only if requested in the Podfile.
-        #
-        def self.default_ld_flags(target, include_objc_flag = false)
-          ld_flags = ''
-          ld_flags << '-ObjC' if include_objc_flag
-          if target.podfile.set_arc_compatibility_flag? &&
-              target.spec_consumers.any?(&:requires_arc?)
-            ld_flags << ' -fobjc-arc'
-          end
-          ld_flags.strip
-        end
-
-        # Configures the given Xcconfig
-        #
-        # @param  [Target] target
-        #         The root target, may be nil.
-        #
-        # @param  [PodTarget] pod_target
-        #         The pod target, which holds the list of +Spec::FileAccessor+.
-        #
-        # @param  [Xcodeproj::Config] xcconfig
-        #         The xcconfig to edit.
-        #
-        # @param  [Boolean] include_ld_flags
-        #         Indicates whether or not to generate ld flags in addition to compile flags
-        #
-        # @param  [Boolean] test_xcconfig
-        #         Whether the settings for dependent targets are being generated for a test xcconfig or not.
-        #
-        # @return [void]
-        #
-        def self.add_settings_for_file_accessors_of_target(target, pod_target, xcconfig, include_ld_flags = true, test_xcconfig = false)
-          file_accessors = pod_target.file_accessors
-          file_accessors = file_accessors.reject { |f| f.spec.test_specification? } unless test_xcconfig
-          file_accessors.each do |file_accessor|
-            if target.nil? || !file_accessor.spec.test_specification?
-              XCConfigHelper.add_spec_build_settings_to_xcconfig(file_accessor.spec_consumer, xcconfig) if include_ld_flags
-              XCConfigHelper.add_static_dependency_build_settings(target, pod_target, xcconfig, file_accessor, include_ld_flags)
-            end
-          end
-          XCConfigHelper.add_dynamic_dependency_build_settings(target, pod_target, xcconfig, include_ld_flags, test_xcconfig)
-          if pod_target.requires_frameworks?
-            pod_target.dependent_targets.each do |dependent_target|
-              XCConfigHelper.add_dynamic_dependency_build_settings(target, dependent_target, xcconfig, include_ld_flags, test_xcconfig)
-            end
-          end
-        end
-
-        # Adds build settings for static vendored frameworks and libraries.
-        #
-        # @param  [Target] target
-        #         The root target, may be nil.
-        #
-        # @param [PodTarget] pod_target
-        #        The pod target, which holds the list of +Spec::FileAccessor+.
-        #
-        # @param [Xcodeproj::Config] xcconfig
-        #        The xcconfig to edit.
-        #
-        # @param [Spec::FileAccessor] file_accessor
-        #        The file accessor, which holds the list of static frameworks.
-        #
-        # @param  [Boolean] include_ld_flags
-        #         Indicates whether or not to generate ld flags in addition to compile flags
-        #
-        # @return [void]
-        #
-        def self.add_static_dependency_build_settings(target, pod_target, xcconfig, file_accessor, include_ld_flags)
-          if target.nil? || !file_accessor.spec.test_specification?
-            adds_other_ldflags = include_ld_flags && XCConfigHelper.links_dependency?(target, pod_target)
-            file_accessor.vendored_static_frameworks.each do |vendored_static_framework|
-              XCConfigHelper.add_framework_build_settings(vendored_static_framework, xcconfig, pod_target.sandbox.root, adds_other_ldflags)
-            end
-            file_accessor.vendored_static_libraries.each do |vendored_static_library|
-              XCConfigHelper.add_library_build_settings(vendored_static_library, xcconfig, pod_target.sandbox.root, adds_other_ldflags)
-            end
-          end
-        end
-
-        # @param  [AggregateTarget] aggregate_target
-        #         The aggregate target, may be nil.
-        #
-        # @param  [PodTarget] pod_target
-        #         The pod target to link or not.
-        #
-        # @return [Boolean] Whether static dependency should be added to the 'OTHER_LDFLAGS'
-        #         of the aggregate target. Aggregate targets that inherit search paths will only link
-        #         if the target has explicitly declared the pod dependency.
-        #
-        def self.links_dependency?(aggregate_target, pod_target)
-          return true if aggregate_target.nil? || aggregate_target.target_definition.inheritance == 'complete'
-          aggregate_target.pod_targets_to_link.include?(pod_target)
-        end
-
-        # Adds build settings for dynamic vendored frameworks and libraries.
-        #
-        # @param  [Target] target
-        #         The root target, may be nil.
-        #
-        # @param [PodTarget] pod_target
-        #        The pod target, which holds the list of +Spec::FileAccessor+.
-        #
-        # @param [Xcodeproj::Config] xcconfig
-        #        The xcconfig to edit.
-        #
-        # @param  [Boolean] include_ld_flags
-        #         Indicates whether or not to generate ld flags in addition to compile flags
-        #
-        # @param  [Boolean] test_xcconfig
-        #         Whether the settings for dependent targets are being generated for a test xcconfig or not.
-        #
-        # @return [void]
-        #
-        def self.add_dynamic_dependency_build_settings(target, pod_target, xcconfig, include_ld_flags, test_xcconfig)
-          file_accessors = pod_target.file_accessors
-          file_accessors = file_accessors.reject { |f| f.spec.test_specification? } unless test_xcconfig
-          file_accessors.each do |file_accessor|
-            if target.nil? || !file_accessor.spec.test_specification?
-              file_accessor.vendored_dynamic_frameworks.each do |vendored_dynamic_framework|
-                XCConfigHelper.add_framework_build_settings(vendored_dynamic_framework, xcconfig, pod_target.sandbox.root, include_ld_flags)
-              end
-              file_accessor.vendored_dynamic_libraries.each do |vendored_dynamic_library|
-                XCConfigHelper.add_library_build_settings(vendored_dynamic_library, xcconfig, pod_target.sandbox.root, include_ld_flags)
-              end
-            end
-          end
-        end
-
-        # Configures the given Xcconfig according to the build settings of the
-        # given Specification.
-        #
-        # @param  [Specification::Consumer] consumer
-        #         The consumer of the specification.
-        #
-        # @param  [Xcodeproj::Config] xcconfig
-        #         The xcconfig to edit.
-        #
-        # @return [void]
-        #
-        def self.add_spec_build_settings_to_xcconfig(consumer, xcconfig)
-          xcconfig.libraries.merge(consumer.libraries)
-          xcconfig.frameworks.merge(consumer.frameworks)
-          xcconfig.weak_frameworks.merge(consumer.weak_frameworks)
-          add_developers_frameworks_if_needed(xcconfig)
-        end
-
-        # Configures the given Xcconfig with the build settings for the given
-        # framework path.
-        #
-        # @param  [Pathname] framework_path
-        #         The path of the framework.
-        #
-        # @param  [Xcodeproj::Config] xcconfig
-        #         The xcconfig to edit.
-        #
-        # @param  [Pathname] sandbox_root
-        #         The path retrieved from Sandbox#root.
-        #
-        # @param  [Boolean] include_ld_flags
-        #         Indicates whether or not to generate ld flags in addition to compile flags
-        #
-        # @return [void]
-        #
-        def self.add_framework_build_settings(framework_path, xcconfig, sandbox_root, include_ld_flags = true)
-          name = File.basename(framework_path, '.framework')
-          dirname = '${PODS_ROOT}/' + framework_path.dirname.relative_path_from(sandbox_root).to_s
-          build_settings = {
-            'FRAMEWORK_SEARCH_PATHS' => quote([dirname]),
-          }
-          build_settings['OTHER_LDFLAGS'] = "-framework \"#{name}\"" if include_ld_flags
-          xcconfig.merge!(build_settings)
-        end
-
-        # Configures the given Xcconfig with the build settings for the given
-        # library path.
-        #
-        # @param  [Pathname] library_path
-        #         The path of the library.
-        #
-        # @param  [Xcodeproj::Config] xcconfig
-        #         The xcconfig to edit.
-        #
-        # @param  [Pathname] sandbox_root
-        #         The path retrieved from Sandbox#root.
-        #
-        # @param  [Boolean] include_ld_flags
-        #         Indicates whether or not to generate ld flags in addition to compile flags
-        #
-        # @return [void]
-        #
-        def self.add_library_build_settings(library_path, xcconfig, sandbox_root, include_ld_flags = true)
-          extension = File.extname(library_path)
-          name = File.basename(library_path, extension).sub(/\Alib/, '')
-          dirname = '${PODS_ROOT}/' + library_path.dirname.relative_path_from(sandbox_root).to_s
-          build_settings = {
-            'LIBRARY_SEARCH_PATHS' => quote([dirname]),
-          }
-          build_settings['OTHER_LDFLAGS'] = "-l\"#{name}\"" if include_ld_flags
-          xcconfig.merge!(build_settings)
-        end
-
-        # Add the code signing settings for generated targets to ensure that
-        # frameworks are correctly signed to be integrated and re-signed when
-        # building the application and embedding the framework
-        #
-        # @param  [Target] target
-        #         The target.
-        #
-        # @param  [Xcodeproj::Config] xcconfig
-        #         The xcconfig to edit.
-        #
-        # @return [void]
-        #
-        def self.add_code_signing_settings(target, xcconfig)
-          build_settings = {}
-          if target.platform.to_sym == :osx
-            build_settings['CODE_SIGN_IDENTITY'] = ''
-          end
-          xcconfig.merge!(build_settings)
-        end
-
-        # Checks if the given target requires specific settings and configures
-        # the given Xcconfig.
-        #
-        # @param  [Target] target
-        #         The target.
-        #
-        # @param  [Xcodeproj::Config] xcconfig
-        #         The xcconfig to edit.
-        #
-        # @return [void]
-        #
-        def self.add_target_specific_settings(target, xcconfig)
-          if target.requires_frameworks?
-            add_code_signing_settings(target, xcconfig)
-          end
-          add_language_specific_settings(target, xcconfig)
-        end
-
-        # Returns the search paths for frameworks and libraries the given target
-        # depends on, so that it can be correctly built and linked.
-        #
-        # @param  [Target] target
-        #         The target.
-        #
-        # @param  [Array<PodTarget>] dependent_targets
-        #         The pod targets the given target depends on.
-        #
-        # @param  [Boolean] test_xcconfig
-        #         Whether the settings for dependent targets are being generated for a test xcconfig or not.
-        #
-        # @return [Hash<String, String>] the settings
-        #
-        def self.search_paths_for_dependent_targets(target, dependent_targets, test_xcconfig = false)
-          dependent_targets = dependent_targets.select(&:should_build?)
-
-          # Filter out dependent targets that are subsets of another target.
-          subset_targets = []
-          dependent_targets.uniq.combination(2) do |a, b|
-            if (a.specs - b.specs).empty?
-              subset_targets << a
-            elsif (b.specs - a.specs).empty?
-              subset_targets << b
-            end
-          end
-          dependent_targets -= subset_targets
-
-          # Alias build dirs to avoid recursive definitions for pod targets and depending
-          # on build settings which could be overwritten in the user target.
-          build_settings = {
-            BUILD_DIR_VARIABLE[2..-2] => '${BUILD_DIR}',
-            CONFIGURATION_BUILD_DIR_VARIABLE[2..-2] => "#{BUILD_DIR_VARIABLE}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)",
-          }
-
-          # Scope pod targets as long as they are not test targets.
-          if !test_xcconfig && target.respond_to?(:configuration_build_dir)
-            build_settings['CONFIGURATION_BUILD_DIR'] = target.configuration_build_dir(CONFIGURATION_BUILD_DIR_VARIABLE)
-          end
-
-          module_map_files = []
-          unless dependent_targets.empty?
-            framework_search_paths = []
-            library_search_paths = []
-            swift_import_paths = []
-            dependent_targets.each do |dependent_target|
-              if dependent_target.requires_frameworks?
-                framework_search_paths << dependent_target.configuration_build_dir(CONFIGURATION_BUILD_DIR_VARIABLE)
-              else
-                library_search_paths << dependent_target.configuration_build_dir(CONFIGURATION_BUILD_DIR_VARIABLE)
-                if dependent_target.defines_module?
-                  module_map_file = if dependent_target.uses_swift?
-                                      # for swift, we have a custom build phase that copies in the module map, appending the .Swift module
-                                      "${PODS_CONFIGURATION_BUILD_DIR}/#{dependent_target.label}/#{dependent_target.product_module_name}.modulemap"
-                                    else
-                                      "${PODS_ROOT}/#{dependent_target.module_map_path.relative_path_from(dependent_target.sandbox.root)}"
-                                    end
-                  module_map_files << %(-fmodule-map-file="#{module_map_file}")
-                  swift_import_paths << dependent_target.configuration_build_dir(CONFIGURATION_BUILD_DIR_VARIABLE) if dependent_target.uses_swift?
-                end
-              end
-            end
-
-            build_settings['FRAMEWORK_SEARCH_PATHS'] = XCConfigHelper.quote(framework_search_paths.uniq)
-            build_settings['LIBRARY_SEARCH_PATHS']   = XCConfigHelper.quote(library_search_paths.uniq)
-            build_settings['SWIFT_INCLUDE_PATHS']    = XCConfigHelper.quote(swift_import_paths.uniq)
-          end
-
-          other_swift_flags = module_map_files.tap(&:uniq!).flat_map { |f| ['-Xcc', f] }
-          if target.is_a?(PodTarget) && !target.requires_frameworks? && target.defines_module? && !test_xcconfig
-            # make it possible for a mixed swift/objc static library to be able to import the objc from within swift
-            other_swift_flags += ['-import-underlying-module', '-Xcc', '-fmodule-map-file="${SRCROOT}/${MODULEMAP_FILE}"']
-          end
-          # unconditionally set these, because of (the possibility of) having to add the pod targets own module map file
-          build_settings['OTHER_CFLAGS']           = module_map_files.join(' ')
-          build_settings['OTHER_SWIFT_FLAGS']      = other_swift_flags.join(' ')
-
-          build_settings
-        end
-
-        # Updates xcconfig with the HEADER_SEARCH_PATHS from the search_paths.
-        #
-        # @param  [Target] search_paths_target
-        #         The target.
-        #
-        # @param  [Xcodeproj::Config] xcconfig
-        #         The xcconfig to edit.
-        #
-        def self.propagate_header_search_paths_from_search_paths(search_paths_target, xcconfig)
-          header_search_paths_list = []
-          search_paths_target.pod_targets.each do |target|
-            target.spec_consumers.each do |spec_consumer|
-              paths = spec_consumer.user_target_xcconfig['HEADER_SEARCH_PATHS']
-              header_search_paths_list <<= paths unless paths.nil?
-            end
-            unless header_search_paths_list == []
-              header_search_paths = header_search_paths_list.join(' ')
-              unless header_search_paths.include? '$(inherited)'
-                header_search_paths = '$(inherited) ' + header_search_paths
-              end
-              build_settings = { 'HEADER_SEARCH_PATHS' => header_search_paths }
-              xcconfig.merge!(build_settings)
-            end
-          end
-        end
-
-        # Add custom build settings and required build settings to link to
-        # vendored libraries and frameworks.
-        #
-        # @param  [Target] target
-        #         The root target, may be nil.
-        #
-        # @param  [Array<PodTarget] dep_targets
-        #         The dependency targets to add the vendored build settings for.
-        #
-        # @param  [Xcodeproj::Config] xcconfig
-        #         The xcconfig to edit.
-        #
-        # @param  [Boolean] include_ld_flags
-        #         Indicates whether or not to generate ld flags in addition to compile flags
-        #
-        # @param  [Boolean] test_xcconfig
-        #         Indicates whether or not the generated ld flags are for a test xcconfig or not
-        #
-        # @note
-        #   In case of generated pod targets, which require frameworks, the
-        #   vendored frameworks and libraries are already linked statically
-        #   into the framework binary and must not be linked again to the
-        #   user target.
-        #
-        def self.generate_vendored_build_settings(target, dep_targets, xcconfig, include_ld_flags = true, test_xcconfig = false)
-          dep_targets.each do |dep_target|
-            unless dep_target.should_build? && dep_target.requires_frameworks? && !dep_target.static_framework?
-              XCConfigHelper.add_settings_for_file_accessors_of_target(target, dep_target, xcconfig, include_ld_flags, test_xcconfig)
-            end
-          end
-        end
-
-        # Ensure to add the default linker run path search paths as they could
-        # be not present due to being historically absent in the project or
-        # target template or just being removed by being superficial when
-        # linking third-party dependencies exclusively statically. This is not
-        # something a project needs specifically for the integration with
-        # CocoaPods, but makes sure that it is self-contained for the given
-        # constraints.
-        #
-        # @param [Target] target
-        #        The target, this can be an aggregate target or a pod target.
-        #
-        # @param [Boolean] requires_host_target
-        #        If this target requires a host target
-        #
-        # @param [Boolean] test_bundle
-        #        Whether this is a test bundle or not. This has an effect when the platform is `osx` and changes
-        #        the runtime search paths accordingly.
-        #
-        # @param [Xcodeproj::Config] xcconfig
-        #        The xcconfig to edit.
-        #
-        # @return [void]
-        #
-        def self.generate_ld_runpath_search_paths(target, requires_host_target, test_bundle, xcconfig)
-          ld_runpath_search_paths = ['$(inherited)']
-          if target.platform.symbolic_name == :osx
-            ld_runpath_search_paths << "'@executable_path/../Frameworks'"
-            ld_runpath_search_paths << \
-              if test_bundle
-                "'@loader_path/../Frameworks'"
-              else
-                "'@loader_path/Frameworks'"
-              end
-          else
-            ld_runpath_search_paths << [
-              "'@executable_path/Frameworks'",
-              "'@loader_path/Frameworks'",
-            ]
-            ld_runpath_search_paths << "'@executable_path/../../Frameworks'" if requires_host_target
-          end
-          xcconfig.merge!('LD_RUNPATH_SEARCH_PATHS' => ld_runpath_search_paths.join(' '))
-        end
-
-        # Add pod target to list of frameworks / libraries that are linked
-        # with the user’s project.
-        #
-        # @param  [AggregateTarget] aggregate_target
-        #         The aggregate target, may be nil.
-        #
-        # @param  [Array<PodTarget] pod_targets
-        #         The pod targets to add the vendored build settings for.
-        #
-        # @param  [Xcodeproj::Config] xcconfig
-        #         The xcconfig to edit.
-        #
-        # @return [void]
-        #
-        def self.generate_other_ld_flags(aggregate_target, pod_targets, xcconfig)
-          # Make sure -framework option gets added for the search paths when static_frameworks are involved.
-          # Otherwise test targets won't link in their primary target's dependencies.
-          unless aggregate_target.nil?
-            dependent_targets = aggregate_target.search_paths_aggregate_targets
-            dependent_targets.each do |dependent_target|
-              if aggregate_target.requires_frameworks? && dependent_target.pod_targets.any?(&:static_framework?)
-                generate_other_ld_flags(dependent_target, dependent_target.pod_targets, xcconfig)
-              end
-            end
-          end
-          other_ld_flags = pod_targets.select(&:should_build?).map do |pod_target|
-            if pod_target.requires_frameworks?
-              %(-framework "#{pod_target.product_basename}")
-            elsif XCConfigHelper.links_dependency?(aggregate_target, pod_target)
-              %(-l "#{pod_target.product_basename}")
-            end
-          end
-          xcconfig.merge!('OTHER_LDFLAGS' => other_ld_flags.compact.join(' '))
-        end
-
-        # Checks if the given target requires language specific settings and
-        # configures the given Xcconfig.
-        #
-        # @param  [Target] target
-        #         The target.
-        #
-        # @param  [Xcodeproj::Config] xcconfig
-        #         The xcconfig to edit.
-        #
-        # @return [void]
-        #
-        def self.add_language_specific_settings(target, xcconfig)
-          if target.uses_swift?
-            other_swift_flags = ['$(inherited)', quote(%w(-D COCOAPODS))]
-            other_swift_flags << quote(%w(-suppress-warnings)) if target.try(:inhibit_warnings?)
-            build_settings = { 'OTHER_SWIFT_FLAGS' => other_swift_flags.join(' ') }
-            xcconfig.merge!(build_settings)
-          end
-        end
-
-        # Adds the search paths of the developer frameworks to the specification
-        # if needed. This is done because the `SenTestingKit` requires them and
-        # adding them to each specification which requires it is repetitive and
-        # error prone.
-        #
-        # @param  [Xcodeproj::Config] xcconfig
-        #         The xcconfig to edit.
-        #
-        # @return [void]
-        #
-        def self.add_developers_frameworks_if_needed(xcconfig)
-          matched_frameworks = xcconfig.frameworks & %w(XCTest SenTestingKit)
-          unless matched_frameworks.empty?
-            search_paths = xcconfig.attributes['FRAMEWORK_SEARCH_PATHS'] ||= ''
-            search_paths_to_add = []
-            search_paths_to_add << '$(inherited)'
-            frameworks_path = '"$(PLATFORM_DIR)/Developer/Library/Frameworks"'
-            search_paths_to_add << frameworks_path
-            search_paths_to_add.each do |search_path|
-              unless search_paths.include?(search_path)
-                search_paths << ' ' unless search_paths.empty?
-                search_paths << search_path
-              end
-            end
-          end
-        end
-
-        #---------------------------------------------------------------------#
-      end
-    end
-  end
-end