cocoapods 1.6.2 → 1.7.0.beta.1

data/lib/cocoapods/target/build_type.rb

@@ -0,0 +1,139 @@
+module Pod
+  class Target
+    class BuildType
+      # @return [Array<Symbol>] known packaging options.
+      #
+      KNOWN_PACKAGING_OPTIONS = %i(library framework).freeze
+
+      # @return [Array<Symbol>] known linking options.
+      #
+      KNOWN_LINKAGE_OPTIONS = %i(static dynamic).freeze
+
+      # @return [Symbol] the packaging for this build type, one of KNOWN_PACKAGING_OPTIONS
+      #
+      attr_reader :packaging
+
+      # @return [Symbol] the linkage for this build type, one of KNOWN_LINKAGE_OPTIONS
+      #
+      attr_reader :linkage
+
+      attr_reader :hash
+
+      def initialize(linkage: :static, packaging: :library)
+        raise ArgumentError, "Invalid linkage option #{linkage.inspect}, valid options are #{KNOWN_LINKAGE_OPTIONS.inspect}" unless KNOWN_LINKAGE_OPTIONS.include?(linkage)
+        raise ArgumentError, "Invalid packaging option #{packaging.inspect}, valid options are #{KNOWN_PACKAGING_OPTIONS.inspect}" unless KNOWN_PACKAGING_OPTIONS.include?(packaging)
+
+        @packaging = packaging
+        @linkage = linkage
+        @hash = packaging.hash ^ linkage.hash
+      end
+
+      # @param  [Specification] spec
+      #         the specification to infer the build type from
+      #
+      # @param  [Boolean] host_requires_frameworks
+      #         whether the host target definition specified `use_frameworks!`
+      #
+      # @return [BuildType] the appropriate build type for the given spec,
+      #         based on whether the host target definition requires frameworks.
+      #
+      def self.infer_from_spec(spec, host_requires_frameworks: false)
+        if host_requires_frameworks
+          root_spec = spec && spec.root
+          if root_spec && root_spec.static_framework
+            static_framework
+          else
+            dynamic_framework
+          end
+        else
+          static_library
+        end
+      end
+
+      # @return [BuildType] the build type for a dynamic library
+      #
+      def self.dynamic_library
+        new(:linkage => :dynamic, :packaging => :library)
+      end
+
+      # @return [BuildType] the build type for a static library
+      #
+      def self.static_library
+        new(:linkage => :static, :packaging => :library)
+      end
+
+      # @return [BuildType] the build type for a dynamic framework
+      #
+      def self.dynamic_framework
+        new(:linkage => :dynamic, :packaging => :framework)
+      end
+
+      # @return [BuildType] the build type for a static framework
+      #
+      def self.static_framework
+        new(:linkage => :static, :packaging => :framework)
+      end
+
+      # @return [Boolean] whether the target is built dynamically
+      #
+      def dynamic?
+        linkage == :dynamic
+      end
+
+      # @return [Boolean] whether the target is built statically
+      #
+      def static?
+        linkage == :static
+      end
+
+      # @return [Boolean] whether the target is built as a framework
+      #
+      def framework?
+        packaging == :framework
+      end
+
+      # @return [Boolean] whether the target is built as a library
+      #
+      def library?
+        packaging == :library
+      end
+
+      # @return [Boolean] whether the target is built as a dynamic framework
+      #
+      def dynamic_framework?
+        dynamic? && framework?
+      end
+
+      # @return [Boolean] whether the target is built as a dynamic library
+      #
+      def dynamic_library?
+        dynamic? && library?
+      end
+
+      # @return [Boolean] whether the target is built as a static framework
+      #
+      def static_framework?
+        static? && framework?
+      end
+
+      # @return [Boolean] whether the target is built as a static library
+      #
+      def static_library?
+        static? && library?
+      end
+
+      def to_s
+        "#{linkage} #{packaging}"
+      end
+
+      def inspect
+        "#<#{self.class} linkage=#{linkage} packaging=#{packaging}>"
+      end
+
+      def ==(other)
+        linkage == other.linkage &&
+            packaging == other.packaging
+      end
+    end
+  end
+end

data/lib/cocoapods/target/framework_paths.rb

@@ -9,14 +9,19 @@ module Pod
       #
       attr_reader :dsym_path
 
-      def initialize(source_path, dsym_path = nil)
+      # @return [Array, Nil] the bcsymbolmap files path array, if one exists
+      #
+      attr_reader :bcsymbolmap_paths
+
+      def initialize(source_path, dsym_path = nil, bcsymbolmap_paths = nil)
         @source_path = source_path
         @dsym_path = dsym_path
+        @bcsymbolmap_paths = bcsymbolmap_paths
       end
 
       def ==(other)
         if other.class == self.class
-          other.source_path == @source_path && other.dsym_path == @dsym_path
+          other.source_path == @source_path && other.dsym_path == @dsym_path && other.bcsymbolmap_paths == @bcsymbolmap_paths
         else
           false
         end
@@ -25,11 +30,11 @@ module Pod
       alias eql? ==
 
       def hash
-        if (dsym = dsym_path)
-          [source_path, dsym].hash
-        else
-          source_path.hash
-        end
+        [source_path, dsym_path, bcsymbolmap_paths].hash
+      end
+
+      def all_paths
+        [source_path, dsym_path, bcsymbolmap_paths].flatten.compact
       end
     end
   end

data/lib/cocoapods/target/pod_target.rb

@@ -14,10 +14,15 @@ module Pod
     #
     attr_reader :test_specs
 
-    # @return [Array<Specification>] All of the specs within this target that are not test specs.
+    # @return [Array<Specification>] All of the specs within this target that are library specs.
     #         Subset of #specs.
     #
-    attr_reader :non_test_specs
+    attr_reader :library_specs
+
+    # @return [Array<Specification>] All of the specs within this target that are app specs.
+    #         Subset of #specs.
+    #
+    attr_reader :app_specs
 
     # @return [Array<TargetDefinition>] the target definitions of the Podfile
     #         that generated this target.
@@ -49,6 +54,18 @@ module Pod
     #
     attr_accessor :test_dependent_targets_by_spec_name
 
+    # @return [Hash{String=>Array<PodTarget>}] all target dependencies by app spec name.
+    #
+    attr_accessor :app_dependent_targets_by_spec_name
+
+    # @return [Hash{String => BuildSettings}] the test spec build settings for this target.
+    #
+    attr_reader :test_spec_build_settings
+
+    # @return [Hash{String => BuildSettings}] the app spec build settings for this target.
+    #
+    attr_reader :app_spec_build_settings
+
     # Initialize a new instance
     #
     # @param [Sandbox] sandbox @see Target#sandbox
@@ -56,13 +73,16 @@ module Pod
     # @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<Specification>] specs @see #specs
     # @param [Array<TargetDefinition>] target_definitions @see #target_definitions
     # @param [Array<Sandbox::FileAccessor>] file_accessors @see #file_accessors
     # @param [String] scope_suffix @see #scope_suffix
+    # @param [Target::BuildType] build_type @see #build_type
     #
     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)
+                   target_definitions, file_accessors = [], scope_suffix = nil,
+                   build_type: Target::BuildType.infer_from_spec(specs.first, :host_requires_frameworks => host_requires_frameworks))
+      super(sandbox, host_requires_frameworks, user_build_configurations, archs, platform, :build_type => build_type)
       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?)
@@ -71,11 +91,17 @@ module Pod
       @target_definitions = target_definitions
       @file_accessors = file_accessors
       @scope_suffix = scope_suffix
-      @test_specs, @non_test_specs = @specs.partition(&:test_specification?)
+      all_specs_by_type = @specs.group_by(&:spec_type)
+      @library_specs = all_specs_by_type[:library] || []
+      @test_specs = all_specs_by_type[:test] || []
+      @app_specs = all_specs_by_type[:app] || []
       @build_headers = Sandbox::HeadersStore.new(sandbox, 'Private', :private)
       @dependent_targets = []
       @test_dependent_targets_by_spec_name = {}
+      @app_dependent_targets_by_spec_name = {}
       @build_config_cache = {}
+      @test_spec_build_settings = create_test_build_settings
+      @app_spec_build_settings = create_app_build_settings
     end
 
     # Scopes the current target based on the existing pod targets within the cache.
@@ -91,7 +117,8 @@ module Pod
         if cache[cache_key]
           cache[cache_key]
         else
-          target = PodTarget.new(sandbox, host_requires_frameworks, user_build_configurations, archs, platform, specs, [target_definition], file_accessors, target_definition.label)
+          target = PodTarget.new(sandbox, host_requires_frameworks, user_build_configurations, archs, platform, specs, [target_definition], file_accessors, target_definition.label,
+                                 :build_type => build_type)
           target.dependent_targets = dependent_targets.flat_map { |pt| pt.scoped(cache) }.select { |pt| pt.target_definitions == [target_definition] }
           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|
@@ -114,18 +141,64 @@ module Pod
       end
     end
 
-    # @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.
+    # @return [Array<FileAccessor>] The list of all files tracked.
+    #
+    def all_files
+      Sandbox::FileAccessor.all_files(file_accessors)
+    end
+
+    # @return [Pathname] the pathname for headers in the sandbox.
+    #
+    def headers_sandbox
+      Pathname.new(pod_name)
+    end
+
+    # @return [Hash{FileAccessor => Hash}] Hash of file accessors by header mappings.
+    #
+    def header_mappings_by_file_accessor
+      valid_accessors = file_accessors.reject { |fa| fa.spec.non_library_specification? }
+      Hash[valid_accessors.map do |file_accessor|
+        # Private headers will always end up in Pods/Headers/Private/PodA/*.h
+        # This will allow for `""` imports to work.
+        [file_accessor, header_mappings(file_accessor, file_accessor.headers)]
+      end]
+    end
+
+    # @return [Hash{FileAccessor => Hash}] Hash of file accessors by public header mappings.
+    #
+    def public_header_mappings_by_file_accessor
+      valid_accessors = file_accessors.reject { |fa| fa.spec.non_library_specification? }
+      Hash[valid_accessors.map do |file_accessor|
+        # Public headers on the other hand will be added in Pods/Headers/Public/PodA/PodA/*.h
+        # The extra folder is intentional in order for `<>` imports to work.
+        [file_accessor, header_mappings(file_accessor, file_accessor.public_headers)]
+      end]
+    end
+
+    # @return [String] the Swift version for the target. If the pod author has provided a set of Swift versions
+    #         supported by their pod then the max Swift version across all of target definitions is chosen, unless
+    #         a target definition specifies explicit requirements for supported Swift versions. Otherwise the Swift
+    #         version is derived by the target definitions that integrate this pod as long as they are the same.
     #
     def swift_version
-      spec_swift_version || target_definitions.map(&:swift_version).compact.uniq.first
+      @swift_version ||= begin
+        if spec_swift_versions.empty?
+          target_definitions.map(&:swift_version).compact.uniq.first
+        else
+          spec_swift_versions.sort.reverse_each.find do |swift_version|
+            target_definitions.all? do |td|
+              td.supports_swift_version?(swift_version)
+            end
+          end.to_s
+        end
+      end
     end
 
-    # @return [String] the Swift version within the root spec. Might be `nil` if none is set.
+    # @return [Array<Version>] the Swift versions supported. Might be empty if the author has not
+    #         specified any versions, most likely due to legacy reasons.
     #
-    def spec_swift_version
-      root_spec.swift_version
+    def spec_swift_versions
+      root_spec.swift_versions
     end
 
     # @return [Podfile] The podfile which declares the dependency.
@@ -148,7 +221,7 @@ module Pod
     #
     def should_build?
       return @should_build if defined? @should_build
-      accessors = file_accessors.reject { |fa| fa.spec.test_specification? }
+      accessors = file_accessors.select { |fa| fa.spec.library_specification? }
       source_files = accessors.flat_map(&:source_files)
       source_files -= accessors.flat_map(&:headers)
       @should_build = !source_files.empty?
@@ -168,40 +241,41 @@ module Pod
       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.
+    # @return [Array<Specification::Consumer>] the test specification consumers for
+    #         the target.
+    #
+    def app_spec_consumers
+      app_specs.map { |app_spec| app_spec.consumer(platform) }
+    end
+
+    # @return [Boolean] Whether the target uses Swift code. This excludes source files from non library specs.
     #
     def uses_swift?
       return @uses_swift if defined? @uses_swift
       @uses_swift = begin
-        file_accessors.reject { |a| a.spec.test_specification? }.any? do |file_accessor|
-          file_accessor.source_files.any? { |sf| sf.extname == '.swift' }
+        file_accessors.select { |a| a.spec.library_specification? }.any? do |file_accessor|
+          uses_swift_for_spec?(file_accessor.spec)
         end
       end
     end
 
-    # Checks whether a particular test specification uses Swift or not.
+    # Checks whether a specification uses Swift or not.
     #
-    # @param  [Specification] test_spec
-    #         The test spec to query against.
+    # @param  [Specification] spec
+    #         The spec to query against.
     #
-    # @return [Boolean] Whether the target uses Swift code within the requested test spec.
+    # @return [Boolean] Whether the target uses Swift code within the requested non library 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
+    def uses_swift_for_spec?(spec)
+      @uses_swift_for_spec_cache ||= {}
+      return @uses_swift_for_spec_cache[spec.name] if @uses_swift_for_spec_cache.key?(spec.name)
+      @uses_swift_for_spec_cache[spec.name] = begin
+        file_accessor = file_accessors.find { |fa| fa.spec == spec }
+        raise "[Bug] Unable to find file accessor for spec `#{spec.inspect}` in pod target `#{label}`" unless file_accessor
+        file_accessor.source_files.any? { |sf| sf.extname == '.swift' }
       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).
     #
@@ -210,7 +284,7 @@ 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 uses_swift? || build_as_framework?
 
       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) }
@@ -225,7 +299,7 @@ module Pod
         return @defines_module = true
       end
 
-      @defines_module = non_test_specs.any? { |s| s.consumer(platform).pod_target_xcconfig['DEFINES_MODULE'] == 'YES' }
+      @defines_module = library_specs.any? { |s| s.consumer(platform).pod_target_xcconfig['DEFINES_MODULE'] == 'YES' }
     end
 
     # @return [Array<Hash{Symbol=>String}>] An array of hashes where each hash represents a single script phase.
@@ -246,6 +320,12 @@ module Pod
       !test_specs.empty?
     end
 
+    # @return [Boolean] Whether the target has any tests specifications.
+    #
+    def contains_app_specifications?
+      !app_specs.empty?
+    end
+
     # @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.
@@ -263,9 +343,18 @@ module Pod
             dsym_source = if dsym_path.exist?
                             "${PODS_ROOT}/#{relative_path_to_sandbox}.dSYM"
                           end
-            FrameworkPaths.new(framework_source, dsym_source)
+            dirname = framework_path.dirname
+            bcsymbolmap_paths = if dirname.exist?
+                                  Dir.chdir(dirname) do
+                                    Dir.glob('*.bcsymbolmap').map do |bcsymbolmap_file_name|
+                                      bcsymbolmap_path = dirname + bcsymbolmap_file_name
+                                      "${PODS_ROOT}/#{bcsymbolmap_path.relative_path_from(sandbox.root)}"
+                                    end
+                                  end
+                                end
+            FrameworkPaths.new(framework_source, dsym_source, bcsymbolmap_paths)
           end
-          if !file_accessor.spec.test_specification? && should_build? && requires_frameworks? && !static_framework?
+          if !file_accessor.spec.test_specification? && should_build? && build_as_dynamic_framework?
             frameworks << FrameworkPaths.new(build_product_path('${BUILT_PRODUCTS_DIR}'))
           end
           hash[file_accessor.spec.name] = frameworks
@@ -279,7 +368,8 @@ module Pod
     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)}" }
+          resource_paths = file_accessor.resources.map { |res| "${PODS_ROOT}/#{res.relative_path_from(sandbox.project_path.dirname)}" }
+          resource_paths = [] if file_accessor.spec.app_specification?
           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" }
@@ -302,7 +392,7 @@ module Pod
       when :unit
         :unit_test_bundle
       else
-        raise Informative, "Unknown test type `#{test_type}`."
+        raise ArgumentError, "Unknown test type `#{test_type}`."
       end
     end
 
@@ -323,7 +413,7 @@ module Pod
     #
     def module_map_path
       basename = "#{label}.modulemap"
-      if requires_frameworks?
+      if build_as_framework?
         super
       elsif file_accessors.any?(&:module_map)
         build_headers.root + product_module_name + basename
@@ -347,49 +437,121 @@ module Pod
       "#{label}-#{bundle_name}"
     end
 
+    # @param  [Specification] subspec
+    #         The subspec to use for producing the label.
+    #
+    # @return [String] The derived name of the target.
+    #
+    def subspec_label(subspec)
+      raise ArgumentError, 'Must not be a root spec' if subspec.root?
+      subspec.name.split('/')[1..-1].join('-').to_s
+    end
+
     # @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_spec)
-      "#{label}-#{test_spec.test_type.capitalize}-#{test_spec.name.split('/')[1..-1].join('-')}"
+      "#{label}-#{test_spec.test_type.capitalize}-#{subspec_label(test_spec)}"
     end
 
-    # @param  [Specification] test_spec
-    #         The test spec this embed frameworks script path is for.
+    # @param  [Specification] app_spec
+    #         The app spec to use for producing the app label.
     #
-    # @return [Pathname] The absolute path of the copy resources script for the given test type.
+    # @return [String] The derived name of the app target.
     #
-    def copy_resources_script_path_for_test_spec(test_spec)
-      support_files_dir + "#{test_target_label(test_spec)}-resources.sh"
+    def app_target_label(app_spec)
+      "#{label}-#{subspec_label(app_spec)}"
     end
 
-    # @param  [Specification] test_spec
-    #         The test spec this embed frameworks script path is for.
+    def non_library_spec_label(spec)
+      case spec.spec_type
+      when :test then test_target_label(spec)
+      when :app then app_target_label(spec)
+      else raise ArgumentError, "Unhandled spec type #{spec.spec_type.inspect} for #{spec.inspect}"
+      end
+    end
+
+    # @param  [Specification] spec
+    #         The spec to return scheme configuration for.
     #
-    # @return [Pathname] The absolute path of the embed frameworks script for the given test type.
+    # @return [Hash] The scheme configuration used or empty if none is specified.
     #
-    def embed_frameworks_script_path_for_test_spec(test_spec)
-      support_files_dir + "#{test_target_label(test_spec)}-frameworks.sh"
+    def scheme_for_spec(spec)
+      spec.consumer(platform).scheme
     end
 
-    # @param  [Specification] test_spec
-    #         The test spec this Info.plist path is for.
+    # @param  [Specification] spec
+    #         The spec this copy resources script path is for.
     #
-    # @return [Pathname] The absolute path of the Info.plist for the given test type.
+    # @return [Pathname] The absolute path of the copy resources script for the given spec.
     #
-    def info_plist_path_for_test_spec(test_spec)
-      support_files_dir + "#{test_target_label(test_spec)}-Info.plist"
+    def copy_resources_script_path_for_spec(spec)
+      support_files_dir + "#{non_library_spec_label(spec)}-resources.sh"
     end
 
-    # @param  [Specification] test_spec
-    #         The test spec this prefix header path is for.
+    # @param  [Specification] spec
+    #         The spec this copy resources script path is for.
     #
-    # @return [Pathname] the absolute path of the prefix header file for the given test type.
+    # @return [Pathname] The absolute path of the copy resources script input file list for the given spec.
     #
-    def prefix_header_path_for_test_spec(test_spec)
-      support_files_dir + "#{test_target_label(test_spec)}-prefix.pch"
+    def copy_resources_script_input_files_path_for_spec(spec)
+      support_files_dir + "#{non_library_spec_label(spec)}-resources-input-files.xcfilelist"
+    end
+
+    # @param  [Specification] spec
+    #         The spec this copy resources script path is for.
+    #
+    # @return [Pathname] The absolute path of the copy resources script output file list for the given spec.
+    #
+    def copy_resources_script_output_files_path_for_spec(spec)
+      support_files_dir + "#{non_library_spec_label(spec)}-resources-output-files.xcfilelist"
+    end
+
+    # @param  [Specification] spec
+    #         The spec this embed frameworks script path is for.
+    #
+    # @return [Pathname] The absolute path of the embed frameworks script for the given spec.
+    #
+    def embed_frameworks_script_path_for_spec(spec)
+      support_files_dir + "#{non_library_spec_label(spec)}-frameworks.sh"
+    end
+
+    # @param  [Specification] spec
+    #         The spec this embed frameworks script path is for.
+    #
+    # @return [Pathname] The absolute path of the embed frameworks script input file list for the given spec.
+    #
+    def embed_frameworks_script_input_files_path_for_spec(spec)
+      support_files_dir + "#{non_library_spec_label(spec)}-frameworks-input-files.xcfilelist"
+    end
+
+    # @param  [Specification] spec
+    #         The spec this embed frameworks script path is for.
+    #
+    # @return [Pathname] The absolute path of the embed frameworks script output file list for the given spec.
+    #
+    def embed_frameworks_script_output_files_path_for_spec(spec)
+      support_files_dir + "#{non_library_spec_label(spec)}-frameworks-output-files.xcfilelist"
+    end
+
+    # @param  [Specification] spec
+    #         The spec this Info.plist path is for.
+    #
+    # @return [Pathname] The absolute path of the Info.plist for the given spec.
+    #
+    def info_plist_path_for_spec(spec)
+      support_files_dir + "#{non_library_spec_label(spec)}-Info.plist"
+    end
+
+    # @param  [Specification] spec
+    #         The spec this prefix header path is for.
+    #
+    # @return [Pathname] the absolute path of the prefix header file for the given spec.
+    #
+    def prefix_header_path_for_spec(spec)
+      support_files_dir + "#{non_library_spec_label(spec)}-prefix.pch"
     end
 
     # @return [Array<String>] The names of the Pods on which this target
@@ -450,6 +612,39 @@ module Pod
       [self, *recursive_dependent_targets, *recursive_test_dependent_targets(test_spec)].uniq
     end
 
+    # @param [Specification] app_spec
+    #        the app spec to scope dependencies for
+    #
+    # @return [Array<PodTarget>] the recursive targets that this target has a
+    #         app dependency upon.
+    #
+    def recursive_app_dependent_targets(app_spec)
+      @recursive_app_dependent_targets ||= {}
+      @recursive_app_dependent_targets[app_spec] ||= _add_recursive_app_dependent_targets(app_spec, Set.new).to_a
+    end
+
+    def _add_recursive_app_dependent_targets(app_spec, set)
+      raise ArgumentError, 'Must give a app spec' unless app_spec
+      return unless dependent_targets = app_dependent_targets_by_spec_name[app_spec.name]
+
+      dependent_targets.each do |target|
+        target._add_recursive_dependent_targets(set) if set.add?(target)
+      end
+
+      set
+    end
+    private :_add_recursive_app_dependent_targets
+
+    # @param [Specification] app_spec
+    #        the app spec to scope dependencies for
+    #
+    # @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 app dependent targets.
+    #
+    def dependent_targets_for_app_spec(app_spec)
+      [self, *recursive_dependent_targets, *recursive_app_dependent_targets(app_spec)].uniq
+    end
+
     # Checks if warnings should be inhibited for this pod.
     #
     # @return [Bool]
@@ -468,11 +663,11 @@ module Pod
         whitelists.first
       else
         UI.warn "The pod `#{pod_name}` is linked to different targets " \
-          "(#{target_definitions.map(&:label)}), which contain different " \
+          "(#{target_definitions.map { |td| "`#{td.label}`" }.to_sentence}), which contain different " \
           'settings to inhibit warnings. CocoaPods does not currently ' \
           'support different settings and will fall back to your preference ' \
           'set in the root target definition.'
-        podfile.root_target_definitions.first.inhibits_warnings_for_pod?(root_spec.name)
+        @inhibit_warnings = podfile.root_target_definitions.first.inhibits_warnings_for_pod?(root_spec.name)
       end
     end
 
@@ -512,24 +707,40 @@ module Pod
     # @param [Boolean] include_dependent_targets_for_test_spec
     #        whether to include header search paths for test dependent targets
     #
+    # @param [Boolean] include_dependent_targets_for_app_spec
+    #        whether to include header search paths for app 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_dependent_targets_for_test_spec: nil, include_private_headers: true)
+    def header_search_paths(include_dependent_targets_for_test_spec: nil, include_dependent_targets_for_app_spec: nil, include_private_headers: true)
       header_search_paths = []
       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(include_dependent_targets_for_test_spec) if include_dependent_targets_for_test_spec
+      dependent_targets += recursive_app_dependent_targets(include_dependent_targets_for_app_spec) if include_dependent_targets_for_app_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
     end
 
+    # @param  [Specification] spec
+    #
+    # @return [BuildSettings::PodTargetSettings] The build settings for the given spec
+    #
+    def build_settings_for_spec(spec)
+      case spec.spec_type
+      when :test then test_spec_build_settings[spec.name]
+      when :app  then app_spec_build_settings[spec.name]
+      else            build_settings
+      end || raise(ArgumentError, "No build settings for #{spec}")
+    end
+
     protected
 
     # Returns whether the pod target should use modular headers.
@@ -552,5 +763,51 @@ module Pod
     def create_build_settings
       BuildSettings::PodTargetSettings.new(self)
     end
+
+    def create_test_build_settings
+      Hash[test_specs.map do |test_spec|
+        [test_spec.name, BuildSettings::PodTargetSettings.new(self, test_spec)]
+      end]
+    end
+
+    def create_app_build_settings
+      Hash[app_specs.map do |app_spec|
+        [app_spec.name, BuildSettings::PodTargetSettings.new(self, app_spec)]
+      end]
+    end
+
+    # Computes the destination sub-directory in the sandbox
+    #
+    # @param  [Sandbox::FileAccessor] file_accessor
+    #         The consumer file accessor for which the headers need to be
+    #         linked.
+    #
+    # @param  [Array<Pathname>] headers
+    #         The absolute paths of the headers which need to be mapped.
+    #
+    # @return [Hash{Pathname => Array<Pathname>}] A hash containing the
+    #         headers folders as the keys and the absolute paths of the
+    #         header files as the values.
+    #
+    def header_mappings(file_accessor, headers)
+      consumer = file_accessor.spec_consumer
+      header_mappings_dir = consumer.header_mappings_dir
+      dir = headers_sandbox
+      dir += consumer.header_dir if consumer.header_dir
+
+      mappings = {}
+      headers.each do |header|
+        next if header.to_s.include?('.framework/')
+
+        sub_dir = dir
+        if header_mappings_dir
+          relative_path = header.relative_path_from(file_accessor.path_list.root + header_mappings_dir)
+          sub_dir += relative_path.dirname
+        end
+        mappings[sub_dir] ||= []
+        mappings[sub_dir] << header
+      end
+      mappings
+    end
   end
 end