cocoapods 1.5.2 → 1.6.1

data/lib/cocoapods/target/pod_target.rb

@@ -1,71 +1,88 @@
+require 'cocoapods/target/framework_paths'
+
 module Pod
   # Stores the information relative to the target used to compile a single Pod.
-  # A pod can have one or more activated spec/subspecs.
+  # A pod can have one or more activated spec, subspecs and test specs.
   #
   class PodTarget < Target
-    # @return [Array<Specification>] the spec and subspecs for the target.
+    # @return [Array<Specification>] the spec, subspecs and test specs of the target.
     #
     attr_reader :specs
 
+    # @return [Array<Specification>] All of the test specs within this target.
+    #         Subset of #specs.
+    #
+    attr_reader :test_specs
+
+    # @return [Array<Specification>] All of the specs within this target that are not test specs.
+    #         Subset of #specs.
+    #
+    attr_reader :non_test_specs
+
     # @return [Array<TargetDefinition>] the target definitions of the Podfile
     #         that generated this target.
     #
     attr_reader :target_definitions
 
-    # @return [HeadersStore] the header directory for the target.
+    # @return [Array<Sandbox::FileAccessor>] the file accessors for the
+    #         specifications of this target.
     #
-    attr_reader :build_headers
+    attr_reader :file_accessors
 
-    # @return [String] used as suffix in the label
+    # @return [String] the suffix used for this target when deduplicated. May be `nil`.
     #
     # @note This affects the value returned by #configuration_build_dir
     #       and accessors relying on this as #build_product_path.
     #
     attr_reader :scope_suffix
 
+    # @return [HeadersStore] the header directory for the target.
+    #
+    attr_reader :build_headers
+
     # @return [Array<PodTarget>] the targets that this target has a dependency
     #         upon.
     #
     attr_accessor :dependent_targets
 
-    # @return [Array<PodTarget>] the targets that this target has a test dependency
-    #         upon.
+    # @return [Hash{String=>Array<PodTarget>}] all target dependencies by test spec name.
     #
-    attr_accessor :test_dependent_targets
+    attr_accessor :test_dependent_targets_by_spec_name
 
-    # return [Array<PBXNativeTarget>] the test target generated in the Pods project for
-    #         this library or `nil` if there is no test target created.
+    # Initialize a new instance
     #
-    attr_accessor :test_native_targets
-
-    # @param [Array<Specification>] specs @see #specs
+    # @param [Sandbox] sandbox @see Target#sandbox
+    # @param [Boolean] host_requires_frameworks @see Target#host_requires_frameworks
+    # @param [Hash{String=>Symbol}] user_build_configurations @see Target#user_build_configurations
+    # @param [Array<String>] archs @see Target#archs
+    # @param [Platform] platform @see Target#platform
     # @param [Array<TargetDefinition>] target_definitions @see #target_definitions
-    # @param [Sandbox] sandbox @see #sandbox
+    # @param [Array<Sandbox::FileAccessor>] file_accessors @see #file_accessors
     # @param [String] scope_suffix @see #scope_suffix
     #
-    def initialize(specs, target_definitions, sandbox, scope_suffix = nil)
+    def initialize(sandbox, host_requires_frameworks, user_build_configurations, archs, platform, specs,
+                   target_definitions, file_accessors = [], scope_suffix = nil)
+      super(sandbox, host_requires_frameworks, user_build_configurations, archs, platform)
       raise "Can't initialize a PodTarget without specs!" if specs.nil? || specs.empty?
       raise "Can't initialize a PodTarget without TargetDefinition!" if target_definitions.nil? || target_definitions.empty?
-      raise "Can't initialize a PodTarget with only abstract TargetDefinitions" if target_definitions.all?(&:abstract?)
+      raise "Can't initialize a PodTarget with only abstract TargetDefinitions!" if target_definitions.all?(&:abstract?)
       raise "Can't initialize a PodTarget with an empty string scope suffix!" if scope_suffix == ''
-      super()
       @specs = specs.dup.freeze
-      @test_specs, @non_test_specs = @specs.partition(&:test_specification?)
       @target_definitions = target_definitions
-      @sandbox = sandbox
+      @file_accessors = file_accessors
       @scope_suffix = scope_suffix
-      @build_headers  = Sandbox::HeadersStore.new(sandbox, 'Private', :private)
-      @file_accessors = []
-      @resource_bundle_targets = []
-      @test_resource_bundle_targets = []
-      @test_native_targets = []
+      @test_specs, @non_test_specs = @specs.partition(&:test_specification?)
+      @build_headers = Sandbox::HeadersStore.new(sandbox, 'Private', :private)
       @dependent_targets = []
-      @test_dependent_targets = []
+      @test_dependent_targets_by_spec_name = {}
       @build_config_cache = {}
     end
 
+    # Scopes the current target based on the existing pod targets within the cache.
+    #
     # @param [Hash{Array => PodTarget}] cache
-    #        the cached PodTarget for a previously scoped (specs, target_definition)
+    #        the cached target for a previously scoped target.
+    #
     # @return [Array<PodTarget>] a scoped copy for each target definition.
     #
     def scoped(cache = {})
@@ -74,13 +91,14 @@ module Pod
         if cache[cache_key]
           cache[cache_key]
         else
-          target = PodTarget.new(specs, [target_definition], sandbox, target_definition.label)
-          target.file_accessors = file_accessors
-          target.user_build_configurations = user_build_configurations
-          target.native_target = native_target
-          target.archs = archs
+          target = PodTarget.new(sandbox, host_requires_frameworks, user_build_configurations, archs, platform, specs, [target_definition], file_accessors, target_definition.label)
           target.dependent_targets = dependent_targets.flat_map { |pt| pt.scoped(cache) }.select { |pt| pt.target_definitions == [target_definition] }
-          target.host_requires_frameworks = host_requires_frameworks
+          target.test_dependent_targets_by_spec_name = Hash[test_dependent_targets_by_spec_name.map do |spec_name, test_pod_targets|
+            scoped_test_pod_targets = test_pod_targets.flat_map do |test_pod_target|
+              test_pod_target.scoped(cache).select { |pt| pt.target_definitions == [target_definition] }
+            end
+            [spec_name, scoped_test_pod_targets]
+          end]
           cache[cache_key] = target
         end
       end
@@ -96,7 +114,7 @@ module Pod
       end
     end
 
-    # @return [String] the Swift version for the target. If the pod author has provided a swift version
+    # @return [String] the Swift version for the target. If the pod author has provided a Swift version
     #                  then that is the one returned, otherwise the Swift version is determined by the user
     #                  targets that include this pod target.
     #
@@ -110,32 +128,6 @@ module Pod
       root_spec.swift_version
     end
 
-    # @note   The deployment target for the pod target is the maximum of all
-    #         the deployment targets for the current platform of the target
-    #         (or the minimum required to support the current installation
-    #         strategy, if higher).
-    #
-    # @return [Platform] the platform for this target.
-    #
-    def platform
-      @platform ||= begin
-        platform_name = target_definitions.first.platform.name
-        default = Podfile::TargetDefinition::PLATFORM_DEFAULTS[platform_name]
-        deployment_target = specs.map do |spec|
-          Version.new(spec.deployment_target(platform_name) || default)
-        end.max
-        if platform_name == :ios && requires_frameworks?
-          minimum = Version.new('8.0')
-          deployment_target = [deployment_target, minimum].max
-        end
-        Platform.new(platform_name, deployment_target)
-      end
-    end
-
-    # @visibility private
-    #
-    attr_writer :platform
-
     # @return [Podfile] The podfile which declares the dependency.
     #
     def podfile
@@ -150,30 +142,15 @@ module Pod
       root_spec.module_name
     end
 
-    # @return [Array<Sandbox::FileAccessor>] the file accessors for the
-    #         specifications of this target.
-    #
-    attr_accessor :file_accessors
-
-    # @return [Array<PBXNativeTarget>] the resource bundle targets belonging
-    #         to this target.
-    attr_reader :resource_bundle_targets
-
-    # @return [Array<PBXNativeTarget>] the resource bundle test targets belonging
-    #         to this target.
-    attr_reader :test_resource_bundle_targets
-
     # @return [Bool] Whether or not this target should be built.
     #
     # A target should not be built if it has no source files.
     #
     def should_build?
       return @should_build if defined? @should_build
-
-      return @should_build = true if contains_script_phases?
-
-      source_files = file_accessors.flat_map(&:source_files)
-      source_files -= file_accessors.flat_map(&:headers)
+      accessors = file_accessors.reject { |fa| fa.spec.test_specification? }
+      source_files = accessors.flat_map(&:source_files)
+      source_files -= accessors.flat_map(&:headers)
       @should_build = !source_files.empty?
     end
 
@@ -184,17 +161,47 @@ module Pod
       specs.map { |spec| spec.consumer(platform) }
     end
 
-    # @return [Boolean] Whether the target uses Swift code.
+    # @return [Array<Specification::Consumer>] the test specification consumers for
+    #         the target.
+    #
+    def test_spec_consumers
+      test_specs.map { |test_spec| test_spec.consumer(platform) }
+    end
+
+    # @return [Boolean] Whether the target uses Swift code. This excludes source files from test specs.
     #
     def uses_swift?
       return @uses_swift if defined? @uses_swift
       @uses_swift = begin
-        file_accessors.any? do |file_accessor|
+        file_accessors.reject { |a| a.spec.test_specification? }.any? do |file_accessor|
+          file_accessor.source_files.any? { |sf| sf.extname == '.swift' }
+        end
+      end
+    end
+
+    # Checks whether a particular test specification uses Swift or not.
+    #
+    # @param  [Specification] test_spec
+    #         The test spec to query against.
+    #
+    # @return [Boolean] Whether the target uses Swift code within the requested test spec.
+    #
+    def uses_swift_for_test_spec?(test_spec)
+      @uses_swift_for_test_type ||= {}
+      return @uses_swift_for_test_type[test_spec.name] if @uses_swift_for_test_type.key?(test_spec.name)
+      @uses_swift_for_test_type[test_spec.name] = begin
+        file_accessors.select { |a| a.spec.test_specification? && a.spec == test_spec }.any? do |file_accessor|
           file_accessor.source_files.any? { |sf| sf.extname == '.swift' }
         end
       end
     end
 
+    # @return [Boolean] Whether the target should build a static framework.
+    #
+    def static_framework?
+      requires_frameworks? && root_spec.static_framework
+    end
+
     # @return [Boolean] Whether the target defines a "module"
     #         (and thus will need a module map and umbrella header).
     #
@@ -204,7 +211,19 @@ module Pod
     def defines_module?
       return @defines_module if defined?(@defines_module)
       return @defines_module = true if uses_swift? || requires_frameworks?
-      return @defines_module = true if target_definitions.any? { |td| td.build_pod_as_module?(pod_name) }
+
+      explicit_target_definitions = target_definitions.select { |td| td.dependencies.any? { |d| d.root_name == pod_name } }
+      tds_by_answer = explicit_target_definitions.group_by { |td| td.build_pod_as_module?(pod_name) }
+
+      if tds_by_answer.size > 1
+        UI.warn "Unable to determine whether to build `#{label}` as a module due to a conflict " \
+          "between the following target definitions:\n\t- #{tds_by_answer.map do |a, td|
+                                                              "`#{td.to_sentence}` #{a ? "requires `#{label}` as a module" : "does not require `#{label}` as a module"}"
+                                                            end.join("\n\t- ")}\n\n" \
+          "Defaulting to skip building `#{label}` as a module."
+      elsif tds_by_answer.keys.first == true || target_definitions.all? { |td| td.build_pod_as_module?(pod_name) }
+        return @defines_module = true
+      end
 
       @defines_module = non_test_specs.any? { |s| s.consumer(platform).pod_target_xcconfig['DEFINES_MODULE'] == 'YES' }
     end
@@ -221,113 +240,51 @@ module Pod
       !script_phases.empty?
     end
 
-    # @return [Hash{Array => Specification}] a hash where the keys are the test native targets and the value
-    #         an array of all the test specs associated with this native target.
-    #
-    def test_specs_by_native_target
-      test_specs.group_by { |test_spec| native_target_for_spec(test_spec) }
-    end
-
     # @return [Boolean] Whether the target has any tests specifications.
     #
     def contains_test_specifications?
       !test_specs.empty?
     end
 
-    # @return [Array<Specification>] All of the test specs within this target.
-    #
-    attr_reader :test_specs
-
-    # @return [Array<Specification>] All of the specs within this target that are not test specs.
-    #
-    attr_reader :non_test_specs
-
-    # @return [Array<Symbol>] All of the test supported types within this target.
-    #
-    def supported_test_types
-      test_specs.map(&:test_type).uniq
-    end
-
-    # Returns the framework paths associated with this target. By default all paths include the framework paths
-    # that are part of test specifications.
-    #
-    # @param  [Boolean] include_test_spec_paths
-    #         Whether to include framework paths from test specifications or not.
-    #
-    # @return [Array<Hash{Symbol => [String]}>] The vendored and non vendored framework paths
-    #         this target depends upon.
-    #
-    def framework_paths(include_test_spec_paths = true)
-      @framework_paths ||= {}
-      return @framework_paths[include_test_spec_paths] if @framework_paths.key?(include_test_spec_paths)
-      @framework_paths[include_test_spec_paths] = begin
-        accessors = file_accessors
-        accessors = accessors.reject { |a| a.spec.test_specification? } unless include_test_spec_paths
-        frameworks = []
-        accessors.flat_map(&:vendored_dynamic_artifacts).map do |framework_path|
-          relative_path_to_sandbox = framework_path.relative_path_from(sandbox.root)
-          framework = { :name => framework_path.basename.to_s,
-                        :input_path => "${PODS_ROOT}/#{relative_path_to_sandbox}",
-                        :output_path => "${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/#{framework_path.basename}" }
-          # Until this can be configured, assume the dSYM file uses the file name as the framework.
-          # See https://github.com/CocoaPods/CocoaPods/issues/1698
-          dsym_name = "#{framework_path.basename}.dSYM"
-          dsym_path = Pathname.new("#{framework_path.dirname}/#{dsym_name}")
-          if dsym_path.exist?
-            framework[:dsym_name] = dsym_name
-            framework[:dsym_input_path] = "${PODS_ROOT}/#{relative_path_to_sandbox}.dSYM"
-            framework[:dsym_output_path] = "${DWARF_DSYM_FOLDER_PATH}/#{dsym_name}"
+    # @return [Hash{String=>Array<FrameworkPaths>}] The vendored and non vendored framework paths this target
+    #         depends upon keyed by spec name. For the root spec and subspecs the framework path of the target itself
+    #         is included.
+    #
+    def framework_paths
+      @framework_paths ||= begin
+        file_accessors.each_with_object({}) do |file_accessor, hash|
+          frameworks = file_accessor.vendored_dynamic_artifacts.map do |framework_path|
+            relative_path_to_sandbox = framework_path.relative_path_from(sandbox.root)
+            framework_source = "${PODS_ROOT}/#{relative_path_to_sandbox}"
+            # Until this can be configured, assume the dSYM file uses the file name as the framework.
+            # See https://github.com/CocoaPods/CocoaPods/issues/1698
+            dsym_name = "#{framework_path.basename}.dSYM"
+            dsym_path = Pathname.new("#{framework_path.dirname}/#{dsym_name}")
+            dsym_source = if dsym_path.exist?
+                            "${PODS_ROOT}/#{relative_path_to_sandbox}.dSYM"
+                          end
+            FrameworkPaths.new(framework_source, dsym_source)
           end
-          frameworks << framework
-        end
-        if should_build? && requires_frameworks? && !static_framework?
-          frameworks << { :name => product_name,
-                          :input_path => build_product_path('${BUILT_PRODUCTS_DIR}'),
-                          :output_path => "${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/#{product_name}" }
+          if !file_accessor.spec.test_specification? && should_build? && requires_frameworks? && !static_framework?
+            frameworks << FrameworkPaths.new(build_product_path('${BUILT_PRODUCTS_DIR}'))
+          end
+          hash[file_accessor.spec.name] = frameworks
         end
-        frameworks
       end
     end
 
-    # Returns the resource paths associated with this target. By default all paths include the resource paths
-    # that are part of test specifications.
-    #
-    # @param  [Boolean] include_test_spec_paths
-    #         Whether to include resource paths from test specifications or not.
-    #
-    # @return [Array<String>] The resource and resource bundle paths this target depends upon.
+    # @return [Hash{String=>Array<String>}] The resource and resource bundle paths this target depends upon keyed by
+    #         spec name.
     #
-    def resource_paths(include_test_spec_paths = true)
-      @resource_paths ||= {}
-      return @resource_paths[include_test_spec_paths] if @resource_paths.key?(include_test_spec_paths)
-      @resource_paths[include_test_spec_paths] = begin
-        accessors = file_accessors
-        accessors = accessors.reject { |a| a.spec.test_specification? } unless include_test_spec_paths
-        resource_paths = accessors.flat_map do |accessor|
-          accessor.resources.flat_map { |res| "${PODS_ROOT}/#{res.relative_path_from(sandbox.project.path.dirname)}" }
+    def resource_paths
+      @resource_paths ||= begin
+        file_accessors.each_with_object({}) do |file_accessor, hash|
+          resource_paths = file_accessor.resources.map { |res| "${PODS_ROOT}/#{res.relative_path_from(sandbox.project.path.dirname)}" }
+          prefix = Pod::Target::BuildSettings::CONFIGURATION_BUILD_DIR_VARIABLE
+          prefix = configuration_build_dir unless file_accessor.spec.test_specification?
+          resource_bundle_paths = file_accessor.resource_bundles.keys.map { |name| "#{prefix}/#{name.shellescape}.bundle" }
+          hash[file_accessor.spec.name] = resource_paths + resource_bundle_paths
         end
-        resource_bundles = accessors.flat_map do |accessor|
-          prefix = Generator::XCConfig::XCConfigHelper::CONFIGURATION_BUILD_DIR_VARIABLE
-          prefix = configuration_build_dir unless accessor.spec.test_specification?
-          accessor.resource_bundles.keys.map { |name| "#{prefix}/#{name.shellescape}.bundle" }
-        end
-        resource_paths + resource_bundles
-      end
-    end
-
-    # Returns the corresponding native target to use based on the provided specification.
-    # This is used to figure out whether to add a source file into the library native target or any of the
-    # test native targets.
-    #
-    # @param  [Specification] spec
-    #         The specification to base from in order to find the native target.
-    #
-    # @return [PBXNativeTarget] the native target to use or `nil` if none is found.
-    #
-    def native_target_for_spec(spec)
-      return native_target unless spec.test_specification?
-      test_native_targets.find do |native_target|
-        native_target.symbol_type == product_type_for_test_type(spec.test_type)
       end
     end
 
@@ -349,22 +306,6 @@ module Pod
       end
     end
 
-    # Returns the corresponding test type given the product type.
-    #
-    # @param  [Symbol] product_type
-    #         The product type to map to a test type.
-    #
-    # @return [Symbol] The native product type to use.
-    #
-    def test_type_for_product_type(product_type)
-      case product_type
-      when :unit_test_bundle
-        :unit
-      else
-        raise Informative, "Unknown product type `#{product_type}`."
-      end
-    end
-
     # @return [Specification] The root specification for the target.
     #
     def root_spec
@@ -391,6 +332,12 @@ module Pod
       end
     end
 
+    # @return [Pathname] the absolute path of the prefix header file.
+    #
+    def prefix_header_path
+      support_files_dir + "#{label}-prefix.pch"
+    end
+
     # @param  [String] bundle_name
     #         The name of the bundle product, which is given by the +spec+.
     #
@@ -400,64 +347,49 @@ module Pod
       "#{label}-#{bundle_name}"
     end
 
-    # @param  [Symbol] test_type
-    #         The test type to use for producing the test label.
+    # @param  [Specification] test_spec
+    #         The test spec to use for producing the test label.
     #
     # @return [String] The derived name of the test target.
     #
-    def test_target_label(test_type)
-      "#{label}-#{test_type.capitalize}-Tests"
+    def test_target_label(test_spec)
+      "#{label}-#{test_spec.test_type.capitalize}-#{test_spec.name.split('/')[1..-1].join('-')}"
     end
 
-    # @param  [Symbol] test_type
-    #         The test type to use for producing the test label.
-    #
-    # @return [String] The label of the app host label to use given the platform and test type.
-    #
-    def app_host_label(test_type)
-      "AppHost-#{Platform.string_name(platform.symbolic_name)}-#{test_type.capitalize}-Tests"
-    end
-
-    # @param  [Symbol] test_type
-    #         The test type this embed frameworks script path is for.
+    # @param  [Specification] test_spec
+    #         The test spec this embed frameworks script path is for.
     #
     # @return [Pathname] The absolute path of the copy resources script for the given test type.
     #
-    def copy_resources_script_path_for_test_type(test_type)
-      support_files_dir + "#{test_target_label(test_type)}-resources.sh"
+    def copy_resources_script_path_for_test_spec(test_spec)
+      support_files_dir + "#{test_target_label(test_spec)}-resources.sh"
     end
 
-    # @param  [Symbol] test_type
-    #         The test type this embed frameworks script path is for.
+    # @param  [Specification] test_spec
+    #         The test spec this embed frameworks script path is for.
     #
     # @return [Pathname] The absolute path of the embed frameworks script for the given test type.
     #
-    def embed_frameworks_script_path_for_test_type(test_type)
-      support_files_dir + "#{test_target_label(test_type)}-frameworks.sh"
+    def embed_frameworks_script_path_for_test_spec(test_spec)
+      support_files_dir + "#{test_target_label(test_spec)}-frameworks.sh"
     end
 
-    # @param  [Symbol] test_type
-    #         The test type this Info.plist path is for.
+    # @param  [Specification] test_spec
+    #         The test spec this Info.plist path is for.
     #
     # @return [Pathname] The absolute path of the Info.plist for the given test type.
     #
-    def info_plist_path_for_test_type(test_type)
-      support_files_dir + "#{test_target_label(test_type)}-Info.plist"
-    end
-
-    # @return [Pathname] the absolute path of the prefix header file.
-    #
-    def prefix_header_path
-      support_files_dir + "#{label}-prefix.pch"
+    def info_plist_path_for_test_spec(test_spec)
+      support_files_dir + "#{test_target_label(test_spec)}-Info.plist"
     end
 
-    # @param  [Symbol] test_type
-    #         The test type prefix header path is for.
+    # @param  [Specification] test_spec
+    #         The test spec this prefix header path is for.
     #
     # @return [Pathname] the absolute path of the prefix header file for the given test type.
     #
-    def prefix_header_path_for_test_type(test_type)
-      support_files_dir + "#{test_target_label(test_type)}-prefix.pch"
+    def prefix_header_path_for_test_spec(test_spec)
+      support_files_dir + "#{test_target_label(test_spec)}-prefix.pch"
     end
 
     # @return [Array<String>] The names of the Pods on which this target
@@ -473,72 +405,49 @@ module Pod
     #         dependency upon.
     #
     def recursive_dependent_targets
-      @recursive_dependent_targets ||= begin
-        targets = dependent_targets.clone
-
-        targets.each do |target|
-          target.dependent_targets.each do |t|
-            targets.push(t) unless t == self || targets.include?(t)
-          end
-        end
+      @recursive_dependent_targets ||= _add_recursive_dependent_targets(Set.new).delete(self).to_a
+    end
 
-        targets
+    def _add_recursive_dependent_targets(set)
+      dependent_targets.each do |target|
+        target._add_recursive_dependent_targets(set) if set.add?(target)
       end
+
+      set
     end
+    protected :_add_recursive_dependent_targets
 
+    # @param [Specification] test_spec
+    #        the test spec to scope dependencies for
+    #
     # @return [Array<PodTarget>] the recursive targets that this target has a
     #         test dependency upon.
     #
-    def recursive_test_dependent_targets
-      @recursive_test_dependent_targets ||= begin
-        targets = test_dependent_targets.clone
+    def recursive_test_dependent_targets(test_spec)
+      @recursive_test_dependent_targets ||= {}
+      @recursive_test_dependent_targets[test_spec] ||= _add_recursive_test_dependent_targets(test_spec, Set.new).to_a
+    end
 
-        targets.each do |target|
-          target.test_dependent_targets.each do |t|
-            targets.push(t) unless t == self || targets.include?(t)
-          end
-        end
+    def _add_recursive_test_dependent_targets(test_spec, set)
+      raise ArgumentError, 'Must give a test spec' unless test_spec
+      return unless dependent_targets = test_dependent_targets_by_spec_name[test_spec.name]
 
-        targets
+      dependent_targets.each do |target|
+        target._add_recursive_dependent_targets(set) if set.add?(target)
       end
-    end
 
-    # @return [Array<PodTarget>] the canonical list of dependent targets this target has a dependency upon.
-    #         This list includes the target itself as well as its recursive dependent and test dependent targets.
-    #
-    def all_dependent_targets
-      [self, *recursive_dependent_targets, *recursive_test_dependent_targets].uniq
+      set
     end
+    private :_add_recursive_test_dependent_targets
 
-    # Checks if the target should be included in the build configuration with
-    # the given name of a given target definition.
-    #
-    # @param  [TargetDefinition] target_definition
-    #         The target definition to check.
+    # @param [Specification] test_spec
+    #        the test spec to scope dependencies for
     #
-    # @param  [String] configuration_name
-    #         The name of the build configuration.
+    # @return [Array<PodTarget>] the canonical list of dependent targets this target has a dependency upon.
+    #         This list includes the target itself as well as its recursive dependent and test dependent targets.
     #
-    def include_in_build_config?(target_definition, configuration_name)
-      key = [target_definition.label, configuration_name]
-      if @build_config_cache.key?(key)
-        return @build_config_cache[key]
-      end
-
-      whitelists = target_definition_dependencies(target_definition).map do |dependency|
-        target_definition.pod_whitelisted_for_configuration?(dependency.name, configuration_name)
-      end.uniq
-
-      if whitelists.empty?
-        @build_config_cache[key] = true
-      elsif whitelists.count == 1
-        @build_config_cache[key] = whitelists.first
-      else
-        raise Informative, "The subspecs of `#{pod_name}` are linked to " \
-          "different build configurations for the `#{target_definition}` " \
-          'target. CocoaPods does not currently support subspecs across ' \
-          'different build configurations.'
-      end
+    def dependent_targets_for_test_spec(test_spec)
+      [self, *recursive_dependent_targets, *recursive_test_dependent_targets(test_spec)].uniq
     end
 
     # Checks if warnings should be inhibited for this pod.
@@ -574,7 +483,7 @@ module Pod
     #
     # @return [String] The absolute path to the configuration build dir
     #
-    def configuration_build_dir(dir = Generator::XCConfig::XCConfigHelper::CONFIGURATION_BUILD_DIR_VARIABLE)
+    def configuration_build_dir(dir = BuildSettings::CONFIGURATION_BUILD_DIR_VARIABLE)
       "#{dir}/#{label}"
     end
 
@@ -583,7 +492,7 @@ module Pod
     #
     # @return [String] The absolute path to the build product
     #
-    def build_product_path(dir = Generator::XCConfig::XCConfigHelper::CONFIGURATION_BUILD_DIR_VARIABLE)
+    def build_product_path(dir = BuildSettings::CONFIGURATION_BUILD_DIR_VARIABLE)
       "#{configuration_build_dir(dir)}/#{product_name}"
     end
 
@@ -600,18 +509,22 @@ module Pod
       [version.major, version.minor, version.patch].join('.')
     end
 
-    # @param [Boolean] include_test_dependent_targets
+    # @param [Boolean] include_dependent_targets_for_test_spec
     #        whether to include header search paths for test dependent targets
     #
+    # @param [Boolean] include_private_headers
+    #        whether to include header search paths for private headers of this
+    #        target
+    #
     # @return [Array<String>] The set of header search paths this target uses.
     #
-    def header_search_paths(include_test_dependent_targets = false)
+    def header_search_paths(include_dependent_targets_for_test_spec: nil, include_private_headers: true)
       header_search_paths = []
-      header_search_paths.concat(build_headers.search_paths(platform, nil, false))
+      header_search_paths.concat(build_headers.search_paths(platform, nil, false)) if include_private_headers
       header_search_paths.concat(sandbox.public_headers.search_paths(platform, pod_name, uses_modular_headers?))
       dependent_targets = recursive_dependent_targets
-      dependent_targets += recursive_test_dependent_targets if include_test_dependent_targets
-      dependent_targets.each do |dependent_target|
+      dependent_targets += recursive_test_dependent_targets(include_dependent_targets_for_test_spec) if include_dependent_targets_for_test_spec
+      dependent_targets.uniq.each do |dependent_target|
         header_search_paths.concat(sandbox.public_headers.search_paths(platform, dependent_target.pod_name, defines_module? && dependent_target.uses_modular_headers?(false)))
       end
       header_search_paths.uniq
@@ -636,18 +549,8 @@ module Pod
 
     private
 
-    # @param  [TargetDefinition] target_definition
-    #         The target definition to check.
-    #
-    # @return [Array<Dependency>] The dependency of the target definition for
-    #         this Pod. Return an empty array if the Pod is not a direct
-    #         dependency of the target definition but the dependency of one or
-    #         more Pods.
-    #
-    def target_definition_dependencies(target_definition)
-      target_definition.dependencies.select do |dependency|
-        Specification.root_name(dependency.name) == pod_name
-      end
+    def create_build_settings
+      BuildSettings::PodTargetSettings.new(self)
     end
   end
 end