cocoapods 1.8.4 → 1.9.0.beta.1

data/lib/cocoapods/target/build_settings.rb

@@ -119,7 +119,7 @@ module Pod
 
           retval = retval.dup if dup_before_freeze && retval.frozen?
 
-          retval.concat(pod_targets_to_link.flat_map { |pod_target| pod_target.build_settings.public_send("#{method_name}_to_import") }) if from_pod_targets_to_link
+          retval.concat(pod_targets_to_link.flat_map { |pod_target| pod_target.build_settings_for_spec(pod_target.root_spec, :configuration => configuration_name).public_send("#{method_name}_to_import") }) if from_pod_targets_to_link
           retval.concat(search_paths_aggregate_target_pod_target_build_settings.flat_map(&from_search_paths_aggregate_targets)) if from_search_paths_aggregate_targets
 
           retval.compact! if compacted
@@ -515,7 +515,10 @@ module Pod
         # @param [Specification] non_library_spec
         #  see {#non_library_spec}
         #
-        def initialize(target, non_library_spec = nil)
+        # @param [Symbol] configuration
+        #  see {#configuration}
+        #
+        def initialize(target, non_library_spec = nil, configuration: nil)
           super(target)
           if @non_library_spec = non_library_spec
             @test_xcconfig = non_library_spec.test_specification?
@@ -527,6 +530,7 @@ module Pod
             @xcconfig_spec_type = :library
             @library_xcconfig = true
           end
+          (@configuration = configuration) || raise("No configuration for #{self}.")
         end
 
         # @return [Xcodeproj::Xconfig]
@@ -567,11 +571,14 @@ module Pod
           if library_xcconfig?
             # We know that this library target is being built dynamically based
             # on the guard above, so include any vendored static frameworks.
-            frameworks.concat vendored_static_frameworks.map { |l| File.basename(l, '.framework') } if target.should_build?
+            if target.should_build?
+              frameworks.concat vendored_static_frameworks.map { |l| File.basename(l, '.framework') }
+              frameworks.concat vendored_xcframeworks.map(&:name)
+            end
             # Also include any vendored dynamic frameworks of dependencies.
-            frameworks.concat dependent_targets.reject(&:should_build?).flat_map { |pt| pt.build_settings.dynamic_frameworks_to_import }
+            frameworks.concat dependent_targets.reject(&:should_build?).flat_map { |pt| pt.build_settings[@configuration].dynamic_frameworks_to_import }
           else
-            frameworks.concat dependent_targets_to_link.flat_map { |pt| pt.build_settings.frameworks_to_import }
+            frameworks.concat dependent_targets_to_link.flat_map { |pt| pt.build_settings[@configuration].frameworks_to_import }
           end
 
           frameworks
@@ -581,6 +588,12 @@ module Pod
         define_build_settings_method :static_frameworks_to_import, :memoized => true do
           static_frameworks_to_import = []
           static_frameworks_to_import.concat vendored_static_frameworks.map { |f| File.basename(f, '.framework') } unless target.should_build? && target.build_as_dynamic?
+          unless target.should_build? && target.build_as_dynamic?
+            static_frameworks_to_import.concat vendored_xcframeworks.
+              select(&:includes_static_slices?).
+              map(&:name).
+              uniq
+          end
           static_frameworks_to_import << target.product_basename if target.should_build? && target.build_as_static_framework?
           static_frameworks_to_import
         end
@@ -588,6 +601,10 @@ module Pod
         # @return [Array<String>]
         define_build_settings_method :dynamic_frameworks_to_import, :memoized => true do
           dynamic_frameworks_to_import = vendored_dynamic_frameworks.map { |f| File.basename(f, '.framework') }
+          dynamic_frameworks_to_import.concat vendored_xcframeworks.
+            select(&:includes_dynamic_slices?).
+            map(&:name).
+            uniq
           dynamic_frameworks_to_import << target.product_basename if target.should_build? && target.build_as_dynamic_framework?
           dynamic_frameworks_to_import.concat consumer_frameworks
           dynamic_frameworks_to_import
@@ -598,7 +615,7 @@ module Pod
           return [] if target.build_as_static? && library_xcconfig?
 
           weak_frameworks = spec_consumers.flat_map(&:weak_frameworks)
-          weak_frameworks.concat dependent_targets.flat_map { |pt| pt.build_settings.weak_frameworks_to_import }
+          weak_frameworks.concat dependent_targets.flat_map { |pt| pt.build_settings[@configuration].weak_frameworks_to_import }
           weak_frameworks
         end
 
@@ -615,7 +632,7 @@ module Pod
         # @return [Array<String>]
         define_build_settings_method :framework_search_paths, :build_setting => true, :memoized => true, :sorted => true, :uniqued => true do
           paths = super().dup
-          paths.concat dependent_targets.flat_map { |t| t.build_settings.framework_search_paths_to_import }
+          paths.concat dependent_targets.flat_map { |pt| pt.build_settings[@configuration].framework_search_paths_to_import }
           paths.concat framework_search_paths_to_import
           paths.delete(target.configuration_build_dir(CONFIGURATION_BUILD_DIR_VARIABLE)) if library_xcconfig?
           paths
@@ -629,7 +646,17 @@ module Pod
 
         # @return [Array<String>]
         define_build_settings_method :vendored_framework_search_paths, :memoized => true do
-          file_accessors.flat_map(&:vendored_frameworks).map { |f| File.join '${PODS_ROOT}', f.dirname.relative_path_from(target.sandbox.root) }
+          search_paths = []
+          search_paths.concat file_accessors.
+            flat_map(&:vendored_frameworks).
+            map { |f| File.join '${PODS_ROOT}', f.dirname.relative_path_from(target.sandbox.root) }
+          # Include each slice in the framework search paths.
+          # Xcode will not search inside an .xcframework for headers within each slice
+          search_paths.concat vendored_xcframeworks.
+            flat_map(&:slices).
+            select { |slice| slice.platform.symbolic_name == target.platform.symbolic_name }.
+            flat_map { |slice| File.join '${PODS_ROOT}', slice.path.dirname.relative_path_from(target.sandbox.root) }
+          search_paths
         end
 
         # @return [Array<String>]
@@ -651,6 +678,11 @@ module Pod
           file_accessors.flat_map(&:vendored_dynamic_frameworks)
         end
 
+        # @return [Array<Xcode::XCFramework>]
+        define_build_settings_method :vendored_xcframeworks, :memoized => true do
+          file_accessors.flat_map(&:vendored_xcframeworks).map { |path| Xcode::XCFramework.new(path) }
+        end
+
         #-------------------------------------------------------------------------#
 
         # @!group Libraries
@@ -676,8 +708,8 @@ module Pod
             libraries.concat libraries_to_import
           end
           if non_library_xcconfig?
-            libraries.concat dependent_targets.flat_map { |pt| pt.build_settings.dynamic_libraries_to_import }
-            libraries.concat dependent_targets_to_link.flat_map { |pt| pt.build_settings.static_libraries_to_import }
+            libraries.concat dependent_targets.flat_map { |pt| pt.build_settings[@configuration].dynamic_libraries_to_import }
+            libraries.concat dependent_targets_to_link.flat_map { |pt| pt.build_settings[@configuration].static_libraries_to_import }
           end
           libraries
         end
@@ -708,11 +740,11 @@ module Pod
           return [] if library_xcconfig? && target.build_as_static?
 
           vendored = library_search_paths_to_import.dup
-          vendored.concat dependent_targets.flat_map { |t| t.build_settings.vendored_dynamic_library_search_paths }
+          vendored.concat dependent_targets.flat_map { |pt| pt.build_settings[@configuration].vendored_dynamic_library_search_paths }
           if library_xcconfig?
             vendored.delete(target.configuration_build_dir(CONFIGURATION_BUILD_DIR_VARIABLE))
           else
-            vendored.concat(dependent_targets.flat_map { |t| t.build_settings.library_search_paths_to_import })
+            vendored.concat(dependent_targets.flat_map { |pt| pt.build_settings[@configuration].library_search_paths_to_import })
           end
           vendored
         end
@@ -751,7 +783,7 @@ module Pod
 
         # @return [Array<String>]
         define_build_settings_method :module_map_files, :memoized => true do
-          dependent_targets.map { |t| t.build_settings.module_map_file_to_import }.compact.sort
+          dependent_targets.map { |pt| pt.build_settings[@configuration].module_map_file_to_import }.compact.sort
         end
 
         # @return [Array<String>]
@@ -770,12 +802,12 @@ module Pod
 
         # @return [Array<String>]
         define_build_settings_method :header_search_paths, :build_setting => true, :memoized => true, :sorted => true do
-          target.header_search_paths(:include_dependent_targets_for_test_spec => test_xcconfig? && non_library_spec, :include_dependent_targets_for_app_spec => app_xcconfig? && non_library_spec)
+          target.header_search_paths(:include_dependent_targets_for_test_spec => test_xcconfig? && non_library_spec, :include_dependent_targets_for_app_spec => app_xcconfig? && non_library_spec, :configuration => @configuration)
         end
 
         # @return [Array<String>]
         define_build_settings_method :public_header_search_paths, :memoized => true, :sorted => true do
-          target.header_search_paths(:include_dependent_targets_for_test_spec => test_xcconfig? && non_library_spec, :include_dependent_targets_for_app_spec => app_xcconfig? && non_library_spec, :include_private_headers => false)
+          target.header_search_paths(:include_dependent_targets_for_test_spec => test_xcconfig? && non_library_spec, :include_dependent_targets_for_app_spec => app_xcconfig? && non_library_spec, :include_private_headers => false, :configuration => @configuration)
         end
 
         #-------------------------------------------------------------------------#
@@ -803,7 +835,7 @@ module Pod
 
         # @return [Array<String>]
         define_build_settings_method :swift_include_paths, :build_setting => true, :memoized => true, :sorted => true, :uniqued => true do
-          paths = dependent_targets.flat_map { |t| t.build_settings.swift_include_paths_to_import }
+          paths = dependent_targets.flat_map { |pt| pt.build_settings[@configuration].swift_include_paths_to_import }
           paths.concat swift_include_paths_to_import if non_library_xcconfig?
           paths
         end
@@ -873,11 +905,11 @@ module Pod
         define_build_settings_method :dependent_targets, :memoized => true do
           select_maximal_pod_targets(
             if test_xcconfig?
-              target.dependent_targets_for_test_spec(non_library_spec)
+              target.dependent_targets_for_test_spec(non_library_spec, :configuration => @configuration)
             elsif app_xcconfig?
-              target.dependent_targets_for_app_spec(non_library_spec)
+              target.dependent_targets_for_app_spec(non_library_spec, :configuration => @configuration)
             else
-              target.recursive_dependent_targets
+              target.recursive_dependent_targets(:configuration => @configuration)
             end,
           )
         end
@@ -886,7 +918,7 @@ module Pod
         define_build_settings_method :dependent_targets_to_link, :memoized => true do
           if test_xcconfig?
             # we're embedding into an app defined by an app spec
-            host_targets = target.app_host_dependent_targets_for_spec(non_library_spec)
+            host_targets = target.app_host_dependent_targets_for_spec(non_library_spec, :configuration => @configuration)
             dependent_targets - host_targets
           else
             dependent_targets
@@ -913,7 +945,7 @@ module Pod
         #
         define_build_settings_method :merged_pod_target_xcconfigs, :memoized => true do
           merged_xcconfigs(pod_target_xcconfig_values_by_consumer_by_key, :pod_target_xcconfig,
-                           :overriding => non_library_xcconfig? ? target.build_settings.merged_pod_target_xcconfigs : {})
+                           :overriding => non_library_xcconfig? ? target.build_settings[@configuration].merged_pod_target_xcconfigs : {})
         end
 
         # @return [Array<Sandbox::FileAccessor>]
@@ -948,21 +980,22 @@ module Pod
           @build_settings_names | BuildSettings.build_settings_names
         end
 
-        # @return [String]
+        # @return [Symbol]
         #   The build configuration these settings will be used for
         attr_reader :configuration_name
 
-        # Intializes a new instance
+        # Initializes a new instance
         #
         # @param [AggregateTarget] target
         #   see {#target}
         #
-        # @param [String] configuration_name
+        # @param [Symbol] configuration_name
         #   see {#configuration_name}
         #
-        def initialize(target, configuration_name)
+        def initialize(target, configuration_name, configuration: nil)
           super(target)
           @configuration_name = configuration_name
+          (@configuration = configuration) || raise("No configuration for #{self}.")
         end
 
         # @return [Xcodeproj::Config] xcconfig
@@ -1034,7 +1067,7 @@ module Pod
           # brackets, @import, etc.)
           paths.concat pod_targets.
             select { |pt| pt.build_as_framework? && pt.should_build? }.
-            map { |pt| pt.build_settings.framework_header_search_path }
+            map { |pt| pt.build_settings[@configuration].framework_header_search_path }
 
           paths.concat target.search_paths_aggregate_targets.flat_map { |at| at.build_settings(configuration_name).header_search_paths }
 
@@ -1051,11 +1084,11 @@ module Pod
           silenced_frameworks = []
           pod_targets_inhibiting_warnings.each do |pt|
             if pt.build_as_framework? && pt.should_build?
-              silenced_headers.append pt.build_settings.framework_header_search_path
+              silenced_headers.append pt.build_settings[@configuration].framework_header_search_path
             else
-              silenced_headers.concat pt.build_settings.public_header_search_paths
+              silenced_headers.concat pt.build_settings[@configuration].public_header_search_paths
             end
-            silenced_frameworks.concat pt.build_settings.framework_search_paths_to_import
+            silenced_frameworks.concat pt.build_settings[@configuration].framework_search_paths_to_import
           end
 
           flags += silenced_headers.uniq.flat_map { |p| ['-isystem', p] }
@@ -1066,7 +1099,7 @@ module Pod
 
         # @return [Array<String>]
         define_build_settings_method :module_map_files, :memoized => true, :sorted => true, :uniqued => true, :compacted => true, :from_search_paths_aggregate_targets => :module_map_file_to_import do
-          pod_targets.map { |t| t.build_settings.module_map_file_to_import }
+          pod_targets.map { |pt| pt.build_settings[@configuration].module_map_file_to_import }
         end
 
         #-------------------------------------------------------------------------#
@@ -1180,7 +1213,7 @@ module Pod
         define_build_settings_method :search_paths_aggregate_target_pod_target_build_settings, :memoized => true, :uniqued => true do
           pod_targets = target.search_paths_aggregate_targets.flat_map { |at| at.build_settings(configuration_name).pod_targets }
           pod_targets = select_maximal_pod_targets(pod_targets)
-          pod_targets.flat_map(&:build_settings)
+          pod_targets.map { |pt| pt.build_settings[@configuration] }
         end
 
         # Returns the +user_target_xcconfig+ for all pod targets and their spec

data/lib/cocoapods/target/pod_target.rb

@@ -1,4 +1,5 @@
-require 'cocoapods/target/framework_paths'
+require 'cocoapods/xcode/framework_paths'
+require 'cocoapods/xcode/xcframework'
 
 module Pod
   # Stores the information relative to the target used to compile a single Pod.
@@ -48,15 +49,59 @@ module Pod
     # @return [Array<PodTarget>] the targets that this target has a dependency
     #         upon.
     #
-    attr_accessor :dependent_targets
+    attr_reader :dependent_targets
+    attr_reader :dependent_targets_by_config
+
+    # @deprecated
+    def dependent_targets=(dependent_targets)
+      @dependent_targets = dependent_targets
+      @dependent_targets_by_config = { :debug => dependent_targets, :release => dependent_targets }
+    end
+
+    def dependent_targets_by_config=(dependent_targets_by_config)
+      @dependent_targets_by_config = dependent_targets_by_config
+      @dependent_targets = dependent_targets_by_config.each_value.reduce([], &:|)
+    end
 
     # @return [Hash{String=>Array<PodTarget>}] all target dependencies by test spec name.
     #
-    attr_accessor :test_dependent_targets_by_spec_name
+    attr_reader :test_dependent_targets_by_spec_name
+    attr_reader :test_dependent_targets_by_spec_name_by_config
+
+    # @deprecated
+    def test_dependent_targets_by_spec_name=(test_dependent_targets_by_spec_name)
+      @test_dependent_targets_by_spec_name = test_dependent_targets_by_spec_name
+      @test_dependent_targets_by_spec_name_by_config = Hash[test_dependent_targets_by_spec_name.map do |k, v|
+        [k, { :debug => v, :release => v }]
+      end]
+    end
+
+    def test_dependent_targets_by_spec_name_by_config=(test_dependent_targets_by_spec_name_by_config)
+      @test_dependent_targets_by_spec_name_by_config = test_dependent_targets_by_spec_name_by_config
+      @test_dependent_targets_by_spec_name = Hash[test_dependent_targets_by_spec_name_by_config.map do |k, v|
+        [k, v.each_value.reduce(Set.new, &:|).to_a]
+      end]
+    end
 
     # @return [Hash{String=>Array<PodTarget>}] all target dependencies by app spec name.
     #
-    attr_accessor :app_dependent_targets_by_spec_name
+    attr_reader :app_dependent_targets_by_spec_name
+    attr_reader :app_dependent_targets_by_spec_name_by_config
+
+    # @deprecated
+    def app_dependent_targets_by_spec_name=(app_dependent_targets_by_spec_name)
+      @app_dependent_targets_by_spec_name = app_dependent_targets_by_spec_name
+      @app_dependent_targets_by_spec_name_by_config = Hash[app_dependent_targets_by_spec_name.map do |k, v|
+        [k, { :debug => v, :release => v }]
+      end]
+    end
+
+    def app_dependent_targets_by_spec_name_by_config=(app_dependent_targets_by_spec_name_by_config)
+      @app_dependent_targets_by_spec_name_by_config = app_dependent_targets_by_spec_name_by_config
+      @app_dependent_targets_by_spec_name = Hash[app_dependent_targets_by_spec_name_by_config.map do |k, v|
+        [k, v.each_value.reduce(Set.new, &:|).to_a]
+      end]
+    end
 
     # @return [Hash{String => (Specification,PodTarget)}] tuples of app specs and pod targets by test spec name.
     #
@@ -65,15 +110,21 @@ module Pod
     # @return [Hash{String => BuildSettings}] the test spec build settings for this target.
     #
     attr_reader :test_spec_build_settings
+    attr_reader :test_spec_build_settings_by_config
 
     # @return [Hash{String => BuildSettings}] the app spec build settings for this target.
     #
     attr_reader :app_spec_build_settings
+    attr_reader :app_spec_build_settings_by_config
+
+    # @return [String] the Swift version for this target.
+    #
+    attr_reader :swift_version
 
     # Initialize a new instance
     #
     # @param [Sandbox] sandbox @see Target#sandbox
-    # @param [Boolean] host_requires_frameworks @see Target#host_requires_frameworks
+    # @param [BuildType] build_type @see Target#build_type
     # @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
@@ -81,12 +132,11 @@ module Pod
     # @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
+    # @param [String] swift_version @see #swift_version
     #
-    def initialize(sandbox, host_requires_frameworks, user_build_configurations, archs, platform, specs,
-                   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)
+    def initialize(sandbox, build_type, user_build_configurations, archs, platform, specs, target_definitions,
+                   file_accessors = [], scope_suffix = nil, swift_version = nil)
+      super(sandbox, build_type, 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 an empty string scope suffix!" if scope_suffix == ''
@@ -94,18 +144,19 @@ module Pod
       @target_definitions = target_definitions
       @file_accessors = file_accessors
       @scope_suffix = scope_suffix
+      @swift_version = swift_version
       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 = {}
+      self.dependent_targets = []
+      self.test_dependent_targets_by_spec_name = Hash[test_specs.map { |ts| [ts.name, []] }]
+      self.app_dependent_targets_by_spec_name = Hash[app_specs.map { |as| [as.name, []] }]
       @test_app_hosts_by_spec_name = {}
       @build_config_cache = {}
-      @test_spec_build_settings = create_test_build_settings
-      @app_spec_build_settings = create_app_build_settings
+      @test_spec_build_settings_by_config = create_test_build_settings_by_config
+      @app_spec_build_settings_by_config = create_app_build_settings_by_config
     end
 
     # Scopes the current target based on the existing pod targets within the cache.
@@ -119,21 +170,20 @@ module Pod
       target_definitions.map do |target_definition|
         cache_key = [specs, target_definition]
         cache[cache_key] ||= begin
-          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 = PodTarget.new(sandbox, build_type, user_build_configurations, archs, platform, specs,
+                                 [target_definition], file_accessors, target_definition.label)
           scope_dependent_targets = ->(dependent_targets) do
             dependent_targets.flat_map do |pod_target|
               pod_target.scoped(cache).select { |pt| pt.target_definitions == [target_definition] }
             end
           end
 
-          target.dependent_targets = scope_dependent_targets[dependent_targets]
-          target.test_dependent_targets_by_spec_name = Hash[test_dependent_targets_by_spec_name.map do |spec_name, test_pod_targets|
-            [spec_name, scope_dependent_targets[test_pod_targets]]
+          target.dependent_targets_by_config = Hash[dependent_targets_by_config.map { |k, v| [k, scope_dependent_targets[v]] }]
+          target.test_dependent_targets_by_spec_name_by_config = Hash[test_dependent_targets_by_spec_name_by_config.map do |spec_name, test_pod_targets_by_config|
+            [spec_name, Hash[test_pod_targets_by_config.map { |k, v| [k, scope_dependent_targets[v]] }]]
           end]
-          target.app_dependent_targets_by_spec_name = Hash[app_dependent_targets_by_spec_name.map do |spec_name, app_pod_targets|
-            [spec_name, scope_dependent_targets[app_pod_targets]]
+          target.app_dependent_targets_by_spec_name_by_config = Hash[app_dependent_targets_by_spec_name_by_config.map do |spec_name, app_pod_targets_by_config|
+            [spec_name, Hash[app_pod_targets_by_config.map { |k, v| [k, scope_dependent_targets[v]] }]]
           end]
           target.test_app_hosts_by_spec_name = Hash[test_app_hosts_by_spec_name.map do |spec_name, (app_host_spec, app_pod_target)|
             [spec_name, [app_host_spec, app_pod_target.scoped(cache).find { |pt| pt.target_definitions == [target_definition] }]]
@@ -187,32 +237,6 @@ module Pod
       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
-      @swift_version ||= begin
-        if spec_swift_versions.empty?
-          target_definition_swift_version
-        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 derived from the target definitions that integrate this pod. This is used for
-    #         legacy reasons and only if the pod author has not specified the Swift versions their pod supports.
-    #
-    def target_definition_swift_version
-      target_definitions.map(&:swift_version).compact.uniq.first
-    end
-
     # @return [Array<Version>] the Swift versions supported. Might be empty if the author has not
     #         specified any versions, most likely due to legacy reasons.
     #
@@ -355,7 +379,7 @@ module Pod
       !app_specs.empty?
     end
 
-    # @return [Hash{String=>Array<FrameworkPaths>}] The vendored and non vendored framework paths this target
+    # @return [Hash{String=>Array<Xcode::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.
     #
@@ -381,10 +405,24 @@ module Pod
                                     end
                                   end
                                 end
-            FrameworkPaths.new(framework_source, dsym_source, bcsymbolmap_paths)
+            Xcode::FrameworkPaths.new(framework_source, dsym_source, bcsymbolmap_paths)
           end
           if file_accessor.spec.library_specification? && should_build? && build_as_dynamic_framework?
-            frameworks << FrameworkPaths.new(build_product_path('${BUILT_PRODUCTS_DIR}'))
+            frameworks << Xcode::FrameworkPaths.new(build_product_path('${BUILT_PRODUCTS_DIR}'))
+          end
+          hash[file_accessor.spec.name] = frameworks
+        end
+      end
+    end
+
+    # @return [Hash{String=>Array<Xcode::XCFramework>}] The vendored xcframeworks this target
+    #         depends upon keyed by spec name.
+    #
+    def xcframeworks
+      @xcframeworks ||= begin
+        file_accessors.each_with_object({}) do |file_accessor, hash|
+          frameworks = file_accessor.vendored_xcframeworks.map do |framework_path|
+            Xcode::XCFramework.new(framework_path)
           end
           hash[file_accessor.spec.name] = frameworks
         end
@@ -556,16 +594,19 @@ module Pod
     # @param [Specification] spec
     #        the spec to return app host dependencies for
     #
+    # @param [String] configuration
+    #        the configuration to retrieve the app host dependent targets for.
+    #
     # @return [Array<PodTarget>] the app host dependent targets for the given spec.
     #
-    def app_host_dependent_targets_for_spec(spec)
+    def app_host_dependent_targets_for_spec(spec, configuration: nil)
       return [] unless spec.test_specification? && spec.consumer(platform).test_type == :unit
       app_host_info = test_app_hosts_by_spec_name[spec.name]
       if app_host_info.nil?
         []
       else
         app_spec, app_target = *app_host_info
-        app_target.dependent_targets_for_app_spec(app_spec)
+        app_target.dependent_targets_for_app_spec(app_spec, :configuration => configuration)
       end
     end
 
@@ -643,6 +684,33 @@ module Pod
       support_files_dir + "#{non_library_spec_label(spec)}-frameworks-output-files.xcfilelist"
     end
 
+    # @param  [Specification] spec
+    #         The spec this script path is for.
+    #
+    # @return [Pathname] The absolute path of the prepare artifacts script for the given spec.
+    #
+    def prepare_artifacts_script_path_for_spec(spec)
+      support_files_dir + "#{non_library_spec_label(spec)}-artifacts.sh"
+    end
+
+    # @param  [Specification] spec
+    #         The spec this script path is for.
+    #
+    # @return [Pathname] The absolute path of the prepare artifacts script input file list for the given spec.
+    #
+    def prepare_artifacts_script_input_files_path_for_spec(spec)
+      support_files_dir + "#{non_library_spec_label(spec)}-artifacts-input-files.xcfilelist"
+    end
+
+    # @param  [Specification] spec
+    #         The spec this script path is for.
+    #
+    # @return [Pathname] The absolute path of the prepare artifacts script output file list for the given spec.
+    #
+    def prepare_artifacts_script_output_files_path_for_spec(spec)
+      support_files_dir + "#{non_library_spec_label(spec)}-artifacts-output-files.xcfilelist"
+    end
+
     # @param  [Specification] spec
     #         The spec this Info.plist path is for.
     #
@@ -670,16 +738,32 @@ module Pod
       end.uniq
     end
 
-    # @return [Array<PodTarget>] the recursive targets that this target has a
-    #         dependency upon.
+    # Returns all dependent targets of this target. If a configuration is passed then the list can be scoped to a given
+    # configuration.
+    #
+    # @param [String] configuration
+    #        The configuration to return the dependent targets for or `nil` if all configurations should be included.
     #
-    def recursive_dependent_targets
-      @recursive_dependent_targets ||= _add_recursive_dependent_targets(Set.new).delete(self).to_a
+    # @return [Array<PodTarget>] the recursive targets that this target has a dependency upon.
+    #
+    def recursive_dependent_targets(configuration: nil)
+      @recursive_dependent_targets ||= begin
+        hash = Hash[config_variants.map do |config|
+          [config, _add_recursive_dependent_targets(Set.new, :configuration => config).delete(self).to_a.freeze]
+        end]
+        hash[nil] = hash.each_value.reduce(Set.new, &:|).to_a
+        hash
+      end
+      @recursive_dependent_targets.fetch(configuration) { raise ArgumentError, "No configuration #{configuration} for #{self}, known configurations are #{@recursive_dependent_targets.keys}" }
     end
 
-    def _add_recursive_dependent_targets(set)
+    def _add_recursive_dependent_targets(set, configuration: nil)
+      if defined?(@recursive_dependent_targets)
+        return set.merge(@recursive_dependent_targets[configuration])
+      end
+      dependent_targets = configuration ? dependent_targets_by_config[configuration] : self.dependent_targets
       dependent_targets.each do |target|
-        target._add_recursive_dependent_targets(set) if set.add?(target)
+        target._add_recursive_dependent_targets(set, :configuration => configuration) if set.add?(target)
       end
 
       set
@@ -689,20 +773,31 @@ module Pod
     # @param [Specification] test_spec
     #        the test spec to scope dependencies for
     #
+    # @param [String] configuration
+    #        the configuration to retrieve the test dependent targets for.
+    #
     # @return [Array<PodTarget>] the recursive targets that this target has a
     #         test dependency upon.
     #
-    def recursive_test_dependent_targets(test_spec)
+    def recursive_test_dependent_targets(test_spec, configuration: nil)
       @recursive_test_dependent_targets ||= {}
-      @recursive_test_dependent_targets[test_spec] ||= _add_recursive_test_dependent_targets(test_spec, Set.new).to_a
+      @recursive_test_dependent_targets[test_spec] ||= begin
+        hash = Hash[config_variants.map do |config|
+          [config, _add_recursive_test_dependent_targets(test_spec, Set.new, :configuration => config).to_a.freeze]
+        end]
+        hash[nil] = hash.each_value.reduce(Set.new, &:|).to_a.freeze
+        hash
+      end
+      @recursive_test_dependent_targets[test_spec][configuration]
     end
 
-    def _add_recursive_test_dependent_targets(test_spec, set)
+    def _add_recursive_test_dependent_targets(test_spec, set, configuration: nil)
       raise ArgumentError, 'Must give a test spec' unless test_spec
-      return unless dependent_targets = test_dependent_targets_by_spec_name[test_spec.name]
+      dependent_targets = configuration ? test_dependent_targets_by_spec_name_by_config[test_spec.name][configuration] : test_dependent_targets_by_spec_name[test_spec.name]
+      raise ArgumentError, "Unable to find deps for #{test_spec} for config #{configuration.inspect} (out of #{test_dependent_targets_by_spec_name_by_config.inspect})" unless dependent_targets
 
       dependent_targets.each do |target|
-        target._add_recursive_dependent_targets(set) if set.add?(target)
+        target._add_recursive_dependent_targets(set, :configuration => configuration) if set.add?(target)
       end
 
       set
@@ -712,30 +807,44 @@ module Pod
     # @param [Specification] test_spec
     #        the test spec to scope dependencies for
     #
+    # @param [String] configuration
+    #        the configuration to retrieve the test dependent targets 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 test dependent targets.
     #
-    def dependent_targets_for_test_spec(test_spec)
-      [self, *recursive_dependent_targets, *recursive_test_dependent_targets(test_spec)].uniq
+    def dependent_targets_for_test_spec(test_spec, configuration: nil)
+      [self, *recursive_dependent_targets(:configuration => configuration), *recursive_test_dependent_targets(test_spec, :configuration => configuration)].uniq
     end
 
     # @param [Specification] app_spec
     #        the app spec to scope dependencies for
     #
+    # @param [String] configuration
+    #        the configuration to retrieve the app dependent targets for.
+    #
     # @return [Array<PodTarget>] the recursive targets that this target has a
     #         app dependency upon.
     #
-    def recursive_app_dependent_targets(app_spec)
+    def recursive_app_dependent_targets(app_spec, configuration: nil)
       @recursive_app_dependent_targets ||= {}
-      @recursive_app_dependent_targets[app_spec] ||= _add_recursive_app_dependent_targets(app_spec, Set.new).to_a
+      @recursive_app_dependent_targets[app_spec] ||= begin
+        hash = Hash[config_variants.map do |config|
+          [config, _add_recursive_app_dependent_targets(app_spec, Set.new, :configuration => config).to_a.freeze]
+        end]
+        hash[nil] = hash.each_value.reduce(Set.new, &:|).to_a.freeze
+        hash
+      end
+      @recursive_app_dependent_targets[app_spec][configuration]
     end
 
-    def _add_recursive_app_dependent_targets(app_spec, set)
+    def _add_recursive_app_dependent_targets(app_spec, set, configuration: nil)
       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 = configuration ? app_dependent_targets_by_spec_name_by_config[app_spec.name][configuration] : app_dependent_targets_by_spec_name[app_spec.name]
+      raise ArgumentError, "Unable to find deps for #{app_spec} for config #{configuration.inspect} #{app_dependent_targets_by_spec_name_by_config.inspect}" unless dependent_targets
 
       dependent_targets.each do |target|
-        target._add_recursive_dependent_targets(set) if set.add?(target)
+        target._add_recursive_dependent_targets(set, :configuration => configuration) if set.add?(target)
       end
 
       set
@@ -745,11 +854,14 @@ module Pod
     # @param [Specification] app_spec
     #        the app spec to scope dependencies for
     #
+    # @param [String] configuration
+    #        the configuration to retrieve the app dependent targets 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
+    def dependent_targets_for_app_spec(app_spec, configuration: nil)
+      [self, *recursive_dependent_targets(:configuration => configuration), *recursive_app_dependent_targets(app_spec, :configuration => configuration)].uniq
     end
 
     # Checks if warnings should be inhibited for this pod.
@@ -821,33 +933,56 @@ module Pod
     #        whether to include header search paths for private headers of this
     #        target
     #
+    # @param [String] configuration
+    #        the configuration to return header search paths for or `nil` for all configurations.
+    #
     # @return [Array<String>] The set of header search paths this target uses.
     #
-    def header_search_paths(include_dependent_targets_for_test_spec: nil, include_dependent_targets_for_app_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, configuration: nil)
       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 = recursive_dependent_targets(:configuration => configuration)
+      if include_dependent_targets_for_test_spec
+        dependent_targets += recursive_test_dependent_targets(include_dependent_targets_for_test_spec, :configuration => configuration)
+      end
+      if include_dependent_targets_for_app_spec
+        dependent_targets += recursive_app_dependent_targets(include_dependent_targets_for_app_spec, :configuration => configuration)
+      end
       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
+    # @param [Specification] spec the specification to return build settings for.
+    #
+    # @param [String] configuration the configuration to scope the build settings.
     #
     # @return [BuildSettings::PodTargetSettings] The build settings for the given spec
     #
-    def build_settings_for_spec(spec)
+    def build_settings_for_spec(spec, configuration: nil)
+      raise ArgumentError, 'Must give configuration' unless configuration
+      configuration = user_build_configurations[configuration] if user_build_configurations.key?(configuration)
+      build_settings_by_config_for_spec(spec)[configuration] || raise(ArgumentError, "No build settings for #{spec} (configuration #{configuration.inspect}) (known configurations #{config_variants})")
+    end
+
+    def build_settings_by_config_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]
+      when :test then test_spec_build_settings_by_config[spec.name]
+      when :app  then app_spec_build_settings_by_config[spec.name]
       else            build_settings
       end || raise(ArgumentError, "No build settings for #{spec}")
     end
 
+    def user_config_names_by_config_type
+      user_build_configurations.each_with_object({}) do |(user, type), hash|
+        hash[type] ||= []
+        hash[type] << user
+      end.each_value(&:freeze).freeze
+    end
+
     protected
 
     # Returns whether the pod target should use modular headers.
@@ -867,19 +1002,33 @@ module Pod
 
     private
 
+    def config_variants
+      if user_build_configurations.empty?
+        %i(debug release)
+      else
+        user_build_configurations.values.uniq
+      end
+    end
+
     def create_build_settings
-      BuildSettings::PodTargetSettings.new(self)
+      Hash[config_variants.map do |config|
+        [config, BuildSettings::PodTargetSettings.new(self, nil, :configuration => config)]
+      end]
     end
 
-    def create_test_build_settings
+    def create_test_build_settings_by_config
       Hash[test_specs.map do |test_spec|
-        [test_spec.name, BuildSettings::PodTargetSettings.new(self, test_spec)]
+        [test_spec.name, Hash[config_variants.map do |config|
+          [config, BuildSettings::PodTargetSettings.new(self, test_spec, :configuration => config)]
+        end]]
       end]
     end
 
-    def create_app_build_settings
+    def create_app_build_settings_by_config
       Hash[app_specs.map do |app_spec|
-        [app_spec.name, BuildSettings::PodTargetSettings.new(self, app_spec)]
+        [app_spec.name, Hash[config_variants.map do |config|
+          [config, BuildSettings::PodTargetSettings.new(self, app_spec, :configuration => config)]
+        end]]
       end]
     end