cocoapods 1.5.3 → 1.6.0.beta.1

data/lib/cocoapods/installer/xcode/pods_project_generator/aggregate_target_installer.rb

@@ -8,21 +8,21 @@ module Pod
         class AggregateTargetInstaller < TargetInstaller
           # Creates the target in the Pods project and the relative support files.
           #
-          # @return [void]
+          # @return [TargetInstallationResult] the result of the installation of this target.
           #
           def install!
             UI.message "- Installing target `#{target.name}` #{target.platform}" do
-              add_target
+              native_target = add_target
               create_support_files_dir
               create_support_files_group
-              create_xcconfig_file
+              create_xcconfig_file(native_target)
               if target.requires_frameworks?
                 create_info_plist_file(target.info_plist_path, native_target, target.version, target.platform)
-                create_module_map
-                create_umbrella_header
+                create_module_map(native_target)
+                create_umbrella_header(native_target)
               elsif target.uses_swift?
-                create_module_map
-                create_umbrella_header
+                create_module_map(native_target)
+                create_umbrella_header(native_target)
               end
               # Because embedded targets live in their host target, CocoaPods
               # copies all of the embedded target's pod_targets to its host
@@ -30,11 +30,13 @@ module Pod
               # cause an App Store rejection because frameworks cannot be
               # embedded in embedded targets.
               #
-              create_embed_frameworks_script unless target.requires_host_target?
-              create_bridge_support_file
-              create_copy_resources_script
+              create_embed_frameworks_script if target.includes_frameworks? && !target.requires_host_target?
+              create_bridge_support_file(native_target)
+              create_copy_resources_script if target.includes_resources?
               create_acknowledgements
-              create_dummy_source
+              create_dummy_source(native_target)
+              clean_support_files_temp_dir
+              TargetInstallationResult.new(target, native_target)
             end
           end
 
@@ -87,14 +89,18 @@ module Pod
 
           # Generates the contents of the xcconfig file and saves it to disk.
           #
+          # @param  [PBXNativeTarget] native_target
+          #         the native target to link the module map file into.
+          #
           # @return [void]
           #
-          def create_xcconfig_file
+          def create_xcconfig_file(native_target)
             native_target.build_configurations.each do |configuration|
+              next unless target.user_build_configurations.key?(configuration.name)
               path = target.xcconfig_path(configuration.name)
-              gen = Generator::XCConfig::AggregateXCConfig.new(target, configuration.name)
-              update_changed_file(gen, path)
-              target.xcconfigs[configuration.name] = gen.xcconfig
+              build_settings = target.build_settings(configuration.name)
+              update_changed_file(build_settings, path)
+              target.xcconfigs[configuration.name] = build_settings.xcconfig
               xcconfig_file_ref = add_file_to_support_group(path)
               configuration.base_configuration_reference = xcconfig_file_ref
             end
@@ -106,9 +112,12 @@ module Pod
           #         target because it is needed for environments interpreted at
           #         runtime.
           #
+          # @param  [PBXNativeTarget] native_target
+          #         the native target to add the bridge support file into.
+          #
           # @return [void]
           #
-          def create_bridge_support_file
+          def create_bridge_support_file(native_target)
             if target.podfile.generate_bridge_support?
               path = target.bridge_support_path
               headers = native_target.headers_build_phase.files.map { |bf| sandbox.root + bf.file_ref.path }

data/lib/cocoapods/installer/xcode/pods_project_generator/app_host_installer.rb

@@ -0,0 +1,95 @@
+module Pod
+  class Installer
+    class Xcode
+      class PodsProjectGenerator
+        # Installs an app host target to a given project.
+        #
+        class AppHostInstaller
+          include TargetInstallerHelper
+
+          # @return [Sandbox]
+          #         The sandbox used for this installation.
+          #
+          attr_reader :sandbox
+
+          # @return [Pod::Project]
+          #         The `Pods/Pods.xcodeproj` to install the app host into.
+          #
+          attr_reader :project
+
+          # @return [Platform] the platform to use for this app host.
+          #
+          attr_reader :platform
+
+          # @return [String] the name to use for this app host target.
+          #
+          attr_reader :name
+
+          # Initialize a new instance
+          #
+          # @param [Sandbox] sandbox @see #sandbox
+          # @param [Pod::Project] project @see #project
+          # @param [Platform] platform @see #platform
+          # @param [String] name @see #name
+          #
+          def initialize(sandbox, project, platform, name)
+            @sandbox = sandbox
+            @project = project
+            @platform = platform
+            @name = name
+          end
+
+          # @return [PBXNativeTarget] the app host native target that was installed.
+          #
+          def install!
+            platform_name = platform.name
+            app_host_target = Pod::Generator::AppTargetHelper.add_app_target(project, platform_name, deployment_target,
+                                                                             name)
+            app_host_target.build_configurations.each do |configuration|
+              configuration.build_settings['PRODUCT_NAME'] = name
+              configuration.build_settings['PRODUCT_BUNDLE_IDENTIFIER'] = 'org.cocoapods.${PRODUCT_NAME:rfc1034identifier}'
+              configuration.build_settings['CODE_SIGN_IDENTITY'] = '' if platform == :osx
+              configuration.build_settings['CURRENT_PROJECT_VERSION'] = '1'
+            end
+            Pod::Generator::AppTargetHelper.add_app_host_main_file(project, app_host_target, platform_name, name)
+            Pod::Generator::AppTargetHelper.add_launchscreen_storyboard(project, app_host_target, name) if platform == :ios
+            additional_entries = platform == :ios ? ADDITIONAL_IOS_INFO_PLIST_ENTRIES : {}
+            create_info_plist_file_with_sandbox(sandbox, app_host_info_plist_path, app_host_target, '1.0.0', platform,
+                                                :appl, additional_entries)
+            project[name].new_file(app_host_info_plist_path)
+            app_host_target
+          end
+
+          private
+
+          ADDITIONAL_IOS_INFO_PLIST_ENTRIES = {
+            'UILaunchStoryboardName' => 'LaunchScreen',
+            'UISupportedInterfaceOrientations' => %w(
+              UIInterfaceOrientationPortrait
+              UIInterfaceOrientationLandscapeLeft
+              UIInterfaceOrientationLandscapeRight
+            ),
+            'UISupportedInterfaceOrientations~ipad' => %w(
+              UIInterfaceOrientationPortrait
+              UIInterfaceOrientationPortraitUpsideDown
+              UIInterfaceOrientationLandscapeLeft
+              UIInterfaceOrientationLandscapeRight
+            ),
+          }.freeze
+
+          # @return [Pathname] The absolute path of the Info.plist to use for an app host.
+          #
+          def app_host_info_plist_path
+            project.path.dirname.+("#{name}/#{name}-Info.plist")
+          end
+
+          # @return [String] The deployment target.
+          #
+          def deployment_target
+            platform.deployment_target.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/installer/xcode/pods_project_generator/file_references_installer.rb

@@ -20,9 +20,9 @@ module Pod
 
           # Initialize a new instance
           #
-          # @param [Sandbox] sandbox @see sandbox
-          # @param [Array<PodTarget>] pod_targets @see pod_targets
-          # @param [Project] pods_project @see pod_project
+          # @param [Sandbox] sandbox @see #sandbox
+          # @param [Array<PodTarget>] pod_targets @see #pod_targets
+          # @param [Project] pods_project @see #pods_project
           #
           def initialize(sandbox, pod_targets, pods_project)
             @sandbox = sandbox
@@ -115,8 +115,9 @@ module Pod
                 next unless sandbox.local?(pod_name)
                 root_name = Specification.root_name(pod_name)
                 paths = file_accessor.developer_files
+                next if paths.empty?
+                group = pods_project.group_for_spec(root_name, :developer)
                 paths.each do |path|
-                  group = pods_project.group_for_spec(root_name, :developer)
                   ref = pods_project.add_file_reference(path, group, false)
                   if path.extname == '.podspec'
                     pods_project.mark_ruby_file_ref(ref)
@@ -143,7 +144,8 @@ module Pod
                 added_build_headers = false
                 added_public_headers = false
 
-                pod_target.file_accessors.each do |file_accessor|
+                file_accessors = pod_target.file_accessors.reject { |fa| fa.spec.test_specification? }
+                file_accessors.each do |file_accessor|
                   # Private headers will always end up in Pods/Headers/Private/PodA/*.h
                   # This will allow for `""` imports to work.
                   header_mappings(headers_sandbox, file_accessor, file_accessor.headers).each do |namespaced_path, files|
@@ -157,13 +159,6 @@ module Pod
                     added_public_headers = true
                     sandbox.public_headers.add_files(namespaced_path, files)
                   end
-
-                  unless pod_target.requires_frameworks?
-                    vendored_frameworks_header_mappings(headers_sandbox, file_accessor).each do |namespaced_path, files|
-                      added_public_headers = true
-                      sandbox.public_headers.add_files(namespaced_path, files)
-                    end
-                  end
                 end
 
                 pod_target.build_headers.add_search_path(headers_sandbox, pod_target.platform) if added_build_headers
@@ -203,13 +198,15 @@ module Pod
           #
           def add_file_accessors_paths_to_pods_group(file_accessor_key, group_key = nil, reflect_file_system_structure_for_development = false)
             file_accessors.each do |file_accessor|
-              pod_name = file_accessor.spec.name
-              local = sandbox.local?(pod_name)
               paths = file_accessor.send(file_accessor_key)
               paths = allowable_project_paths(paths)
+              next if paths.empty?
+
+              pod_name = file_accessor.spec.name
+              local = sandbox.local?(pod_name)
               base_path = local ? common_path(paths) : nil
+              group = pods_project.group_for_spec(pod_name, group_key)
               paths.each do |path|
-                group = pods_project.group_for_spec(pod_name, group_key)
                 pods_project.add_file_reference(path, group, local && reflect_file_system_structure_for_development, base_path)
               end
             end
@@ -329,36 +326,6 @@ module Pod
             mappings
           end
 
-          # Computes the destination sub-directory in the sandbox for headers
-          # from inside vendored frameworks.
-          #
-          # @param  [Pathname] headers_sandbox
-          #         The sandbox where the header links should be stored for this
-          #         Pod.
-          #
-          # @param  [Sandbox::FileAccessor] file_accessor
-          #         The consumer file accessor for which the headers need to be
-          #         linked.
-          #
-          def vendored_frameworks_header_mappings(headers_sandbox, file_accessor)
-            mappings = {}
-            file_accessor.vendored_frameworks.each do |framework|
-              headers_dir = Sandbox::FileAccessor.vendored_frameworks_headers_dir(framework)
-              headers = Sandbox::FileAccessor.vendored_frameworks_headers(framework)
-              framework_name = framework.basename(framework.extname)
-              dir = headers_sandbox + framework_name
-              headers.each do |header|
-                # the relative path of framework headers should be kept,
-                # not flattened like is done for most public headers.
-                relative_path = header.relative_path_from(headers_dir)
-                sub_dir = dir + relative_path.dirname
-                mappings[sub_dir] ||= []
-                mappings[sub_dir] << header
-              end
-            end
-            mappings
-          end
-
           #-----------------------------------------------------------------------#
         end
       end

data/lib/cocoapods/installer/xcode/pods_project_generator/pod_target_installer.rb

@@ -6,75 +6,105 @@ module Pod
         # relative support files.
         #
         class PodTargetInstaller < TargetInstaller
+          require 'cocoapods/installer/xcode/pods_project_generator/app_host_installer'
+
+          # @return [Array<Pathname>] Array of umbrella header paths in the headers directory
+          #
+          attr_reader :umbrella_header_paths
+
+          # Initialize a new instance
+          #
+          # @param [Sandbox] sandbox @see TargetInstaller#sandbox
+          # @param [Pod::Project] project @see TargetInstaller#project
+          # @param [Target] target @see TargetInstaller#target
+          # @param [Array<Pathname>] umbrella_header_paths @see #umbrella_header_paths
+          #
+          def initialize(sandbox, project, target, umbrella_header_paths = nil)
+            super(sandbox, project, target)
+            @umbrella_header_paths = umbrella_header_paths
+          end
+
           # Creates the target in the Pods project and the relative support files.
           #
-          # @return [void]
+          # @return [TargetInstallationResult] the result of the installation of this target.
           #
           def install!
-            unless target.should_build?
-              add_resources_bundle_targets
-              return
-            end
-
             UI.message "- Installing target `#{target.name}` #{target.platform}" do
-              add_target
               create_support_files_dir
-              if target.contains_test_specifications?
-                add_test_targets
-                add_test_app_host_targets
+              test_file_accessors, file_accessors = target.file_accessors.partition { |fa| fa.spec.test_specification? }
+
+              unless target.should_build?
+                # For targets that should not be built (e.g. pre-built vendored frameworks etc), we add a placeholder
+                # PBXAggregateTarget that will be used to wire up dependencies later.
+                native_target = add_placeholder_target
+                resource_bundle_targets = add_resources_bundle_targets(file_accessors).values.flatten
+                create_xcconfig_file(native_target, resource_bundle_targets)
+                return TargetInstallationResult.new(target, native_target, resource_bundle_targets)
               end
-              add_resources_bundle_targets
-              add_files_to_build_phases
-              create_xcconfig_file
-              create_test_xcconfig_files if target.contains_test_specifications?
+
+              native_target = add_target
+              resource_bundle_targets = add_resources_bundle_targets(file_accessors).values.flatten
+
+              test_native_targets = add_test_targets
+              test_app_host_targets = add_test_app_host_targets(test_native_targets)
+              test_resource_bundle_targets = add_resources_bundle_targets(test_file_accessors)
+
+              add_files_to_build_phases(native_target, test_native_targets)
+
+              create_xcconfig_file(native_target, resource_bundle_targets)
+              create_test_xcconfig_files(test_native_targets, test_resource_bundle_targets)
 
               if target.defines_module?
-                create_module_map do |generator|
+                create_module_map(native_target) do |generator|
                   generator.headers.concat module_map_additional_headers
                 end
-                create_umbrella_header do |generator|
-                  file_accessors = target.file_accessors
-                  file_accessors = file_accessors.reject { |f| f.spec.test_specification? } if target.contains_test_specifications?
-                  generator.imports += if header_mappings_dir
-                                         file_accessors.flat_map(&:public_headers).map do |pathname|
-                                           pathname.relative_path_from(header_mappings_dir)
-                                         end
-                                       else
-                                         file_accessors.flat_map(&:public_headers).map(&:basename)
+                create_umbrella_header(native_target) do |generator|
+                  generator.imports += file_accessors.flat_map do |file_accessor|
+                    header_dir = if !target.requires_frameworks? && dir = file_accessor.spec_consumer.header_dir
+                                   Pathname.new(dir)
+                    end
+
+                    file_accessor.public_headers.map do |public_header|
+                      public_header = if header_mappings_dir
+                                        public_header.relative_path_from(header_mappings_dir)
+                                      else
+                                        public_header.basename
                                       end
+                      if header_dir
+                        public_header = header_dir.join(public_header)
+                      end
+                      public_header
+                    end
+                  end
                 end
               end
 
               if target.requires_frameworks?
-                unless target.static_framework?
+                unless skip_info_plist?(native_target)
                   create_info_plist_file(target.info_plist_path, native_target, target.version, target.platform)
                 end
-                create_build_phase_to_symlink_header_folders
+                create_build_phase_to_symlink_header_folders(native_target)
               elsif target.uses_swift?
-                add_swift_static_library_compatibility_header_phase
+                add_swift_static_library_compatibility_header_phase(native_target)
               end
 
               unless skip_pch?(target.non_test_specs)
                 path = target.prefix_header_path
-                file_accessors = target.file_accessors.reject { |f| f.spec.test_specification? }
                 create_prefix_header(path, file_accessors, target.platform, [native_target])
               end
               unless skip_pch?(target.test_specs)
-                target.supported_test_types.each do |test_type|
-                  path = target.prefix_header_path_for_test_type(test_type)
-                  file_accessors = target.file_accessors.select { |f| f.spec.test_specification? }
-                  create_prefix_header(path, file_accessors, target.platform, target.test_native_targets)
+                target.test_specs.each do |test_spec|
+                  path = target.prefix_header_path_for_test_spec(test_spec)
+                  create_prefix_header(path, test_file_accessors, target.platform, test_native_targets)
                 end
               end
-              create_dummy_source
+              create_dummy_source(native_target)
+              clean_support_files_temp_dir
+              TargetInstallationResult.new(target, native_target, resource_bundle_targets, test_native_targets,
+                                           test_resource_bundle_targets, test_app_host_targets)
             end
           end
 
-          # @return [Hash<Pathname,Pathname>] A hash of all umbrella headers, grouped by the directory
-          #         the are stored in
-          #
-          attr_accessor :umbrella_headers_by_dir
-
           private
 
           # @param [Array<Specification>] specs
@@ -86,6 +116,18 @@ module Pod
             specs.any? { |spec| spec.prefix_header_file.is_a?(FalseClass) }
           end
 
+          # True if info.plist generation should be skipped
+          #
+          # @param [PXNativeTarget] native_target
+          #
+          # @return [Boolean] Whether the target should build an Info.plist file
+          #
+          def skip_info_plist?(native_target)
+            return true if target.static_framework?
+            existing_setting = native_target.resolved_build_setting('INFOPLIST_FILE', true).values.compact
+            !existing_setting.empty?
+          end
+
           # Remove the default headers folder path settings for static library pod
           # targets.
           #
@@ -158,8 +200,6 @@ module Pod
 
           #-----------------------------------------------------------------------#
 
-          SOURCE_FILE_EXTENSIONS = Sandbox::FileAccessor::SOURCE_FILE_EXTENSIONS
-
           # Adds the build files of the pods to the target and adds a reference to
           # the frameworks of the Pods.
           #
@@ -173,20 +213,26 @@ module Pod
           #
           # @return [void]
           #
-          def add_files_to_build_phases
+          def add_files_to_build_phases(native_target, test_native_targets)
             target.file_accessors.each do |file_accessor|
               consumer = file_accessor.spec_consumer
 
-              native_target = target.native_target_for_spec(consumer.spec)
+              native_target = if !consumer.spec.test_specification?
+                                native_target
+                              else
+                                test_native_target_from_spec_consumer(consumer, test_native_targets)
+                              end
+
               headers = file_accessor.headers
               public_headers = file_accessor.public_headers.map(&:realpath)
               private_headers = file_accessor.private_headers.map(&:realpath)
-              other_source_files = file_accessor.source_files.reject { |sf| SOURCE_FILE_EXTENSIONS.include?(sf.extname) }
+              other_source_files = file_accessor.other_source_files
 
               {
                 true => file_accessor.arc_source_files,
                 false => file_accessor.non_arc_source_files,
               }.each do |arc, files|
+                next if files.empty?
                 files = files - headers - other_source_files
                 flags = compiler_flags_for_consumer(consumer, arc)
                 regular_file_refs = project_file_references_array(files, 'source')
@@ -210,62 +256,27 @@ module Pod
             end
           end
 
-          # Adds the test app host targets for the library to the Pods project with the
-          # appropriate build configurations.
-          #
-          # @return [void]
-          #
-          def add_test_app_host_targets
-            target.test_specs.each do |test_spec|
-              next unless test_spec.consumer(target.platform).requires_app_host?
-              name = target.app_host_label(test_spec.test_type)
-              platform_name = target.platform.name
-              app_host_target = project.targets.find { |t| t.name == name }
-              if app_host_target.nil?
-                app_host_target = Pod::Generator::AppTargetHelper.add_app_target(project, platform_name, deployment_target, name)
-                app_host_target.build_configurations.each do |configuration|
-                  configuration.build_settings.merge!(custom_build_settings)
-                  configuration.build_settings['PRODUCT_NAME'] = name
-                  configuration.build_settings['PRODUCT_BUNDLE_IDENTIFIER'] = 'org.cocoapods.${PRODUCT_NAME:rfc1034identifier}'
-                  configuration.build_settings['CODE_SIGN_IDENTITY'] = '' if target.platform == :osx
-                end
-                Pod::Generator::AppTargetHelper.add_app_host_main_file(project, app_host_target, platform_name, name)
-                app_host_info_plist_path = project.path.dirname.+("#{name}/Info.plist")
-                create_info_plist_file(app_host_info_plist_path, app_host_target, '1.0.0', target.platform, :appl)
-              end
-              # Wire all test native targets with the app host.
-              native_test_target = target.native_target_for_spec(test_spec)
-              native_test_target.build_configurations.each do |configuration|
-                test_host = "$(BUILT_PRODUCTS_DIR)/#{name}.app/"
-                test_host << 'Contents/MacOS/' if target.platform == :osx
-                test_host << name.to_s
-                configuration.build_settings['TEST_HOST'] = test_host
-              end
-              target_attributes = project.root_object.attributes['TargetAttributes'] || {}
-              target_attributes[native_test_target.uuid.to_s] = { 'TestTargetID' => app_host_target.uuid.to_s }
-              project.root_object.attributes['TargetAttributes'] = target_attributes
-            end
-          end
-
           # Adds the test targets for the library to the Pods project with the
           # appropriate build configurations.
           #
-          # @return [void]
+          # @return [Array<PBXNativeTarget>] the test native targets created.
           #
           def add_test_targets
-            target.supported_test_types.each do |test_type|
+            target.test_specs.map do |test_spec|
+              spec_consumer = test_spec.consumer(target.platform)
+              test_type = spec_consumer.test_type
               product_type = target.product_type_for_test_type(test_type)
-              name = target.test_target_label(test_type)
+              name = target.test_target_label(test_spec)
               platform_name = target.platform.name
-              language = target.all_dependent_targets.any?(&:uses_swift?) ? :swift : :objc
-              native_test_target = project.new_target(product_type, name, platform_name, deployment_target, nil, language)
-              native_test_target.product_reference.name = name
+              language = target.uses_swift_for_test_spec?(test_spec) ? :swift : :objc
+              test_native_target = project.new_target(product_type, name, platform_name, deployment_target, nil, language)
+              test_native_target.product_reference.name = name
 
               target.user_build_configurations.each do |bc_name, type|
-                native_test_target.add_build_configuration(bc_name, type)
+                test_native_target.add_build_configuration(bc_name, type)
               end
 
-              native_test_target.build_configurations.each do |configuration|
+              test_native_target.build_configurations.each do |configuration|
                 configuration.build_settings.merge!(custom_build_settings)
                 # target_installer will automatically add an empty `OTHER_LDFLAGS`. For test
                 # targets those are set via a test xcconfig file instead.
@@ -288,15 +299,46 @@ module Pod
               end
 
               # Test native targets also need frameworks and resources to be copied over to their xctest bundle.
-              create_test_target_embed_frameworks_script(test_type)
-              create_test_target_copy_resources_script(test_type)
+              create_test_target_embed_frameworks_script(test_spec)
+              create_test_target_copy_resources_script(test_spec)
 
-              # Generate vanila Info.plist for test target similar to the one xcode gererates for new test target.
+              # Generate vanilla Info.plist for test target similar to the one Xcode generates for new test target.
               # This creates valid test bundle accessible at the runtime, allowing tests to load bundle resources
               # defined in podspec.
-              create_info_plist_file(target.info_plist_path_for_test_type(test_type), native_test_target, '1.0', target.platform, :bndl)
+              create_info_plist_file(target.info_plist_path_for_test_spec(test_spec), test_native_target, '1.0', target.platform, :bndl)
 
-              target.test_native_targets << native_test_target
+              test_native_target
+            end
+          end
+
+          # Adds the test app host targets for the library to the Pods project with the
+          # appropriate build configurations.
+          #
+          # @param  [Array<PBXNativeTarget>] test_native_targets
+          #         the test native targets that have been created to use as a lookup when linking the app host to.
+          #
+          # @return [Array<PBXNativeTarget>] the app host targets created.
+          #
+          def add_test_app_host_targets(test_native_targets)
+            target.test_spec_consumers.select(&:requires_app_host?).group_by(&:test_type).map do |test_type, test_spec_consumers|
+              platform = target.platform
+              name = "AppHost-#{target.label}-#{test_type.capitalize}-Tests"
+              app_host_target = AppHostInstaller.new(sandbox, project, platform, name).install!
+              # Wire test native targets to the generated app host.
+              test_spec_consumers.each do |test_spec_consumer|
+                test_native_target = test_native_target_from_spec_consumer(test_spec_consumer, test_native_targets)
+                test_native_target.build_configurations.each do |configuration|
+                  test_host = "$(BUILT_PRODUCTS_DIR)/#{app_host_target.name}.app/"
+                  test_host << 'Contents/MacOS/' if platform == :osx
+                  test_host << app_host_target.name.to_s
+                  configuration.build_settings['TEST_HOST'] = test_host
+                end
+                target_attributes = project.root_object.attributes['TargetAttributes'] || {}
+                target_attributes[test_native_target.uuid.to_s] = { 'TestTargetID' => app_host_target.uuid.to_s }
+                project.root_object.attributes['TargetAttributes'] = target_attributes
+                test_native_target.add_dependency(app_host_target)
+              end
+              app_host_target
             end
           end
 
@@ -305,58 +347,53 @@ module Pod
           # @note   The source files are grouped by Pod and in turn by subspec
           #         (recursively) in the resources group.
           #
-          # @return [void]
+          # @param  [Array<Sandbox::FileAccessor>] file_accessors
+          #         the file accessors list to generate resource bundles for.
           #
-          def add_resources_bundle_targets
-            target.file_accessors.each do |file_accessor|
-              file_accessor.resource_bundles.each do |bundle_name, paths|
+          # @return [Array<PBXNativeTarget] the resource bundle native targets created.
+          #
+          def add_resources_bundle_targets(file_accessors)
+            file_accessors.each_with_object({}) do |file_accessor, hash|
+              hash[file_accessor.spec.name] = file_accessor.resource_bundles.map do |bundle_name, paths|
                 label = target.resources_bundle_target_label(bundle_name)
-                bundle_target = project.new_resources_bundle(label, file_accessor.spec_consumer.platform_name)
-                bundle_target.product_reference.tap do |bundle_product|
+                resource_bundle_target = project.new_resources_bundle(label, file_accessor.spec_consumer.platform_name)
+                resource_bundle_target.product_reference.tap do |bundle_product|
                   bundle_file_name = "#{bundle_name}.bundle"
                   bundle_product.name = bundle_file_name
                 end
 
+                contains_compile_phase_refs = false
                 filter_resource_file_references(paths) do |resource_phase_refs, compile_phase_refs|
                   # Resource bundles are only meant to have resources, so install everything
                   # into the resources phase. See note in filter_resource_file_references.
-                  bundle_target.add_resources(resource_phase_refs + compile_phase_refs)
+                  resource_bundle_target.add_resources(resource_phase_refs + compile_phase_refs)
+                  contains_compile_phase_refs = !compile_phase_refs.empty?
                 end
 
-                native_target = target.native_target_for_spec(file_accessor.spec_consumer.spec)
                 target.user_build_configurations.each do |bc_name, type|
-                  bundle_target.add_build_configuration(bc_name, type)
-                end
-                bundle_target.deployment_target = deployment_target
-
-                test_specification = file_accessor.spec.test_specification?
-
-                if test_specification
-                  target.test_resource_bundle_targets << bundle_target
-                else
-                  target.resource_bundle_targets << bundle_target
-                end
-
-                if target.should_build?
-                  native_target.add_dependency(bundle_target)
-                  if target.requires_frameworks?
-                    native_target.add_resources([bundle_target.product_reference])
-                  end
+                  resource_bundle_target.add_build_configuration(bc_name, type)
                 end
+                resource_bundle_target.deployment_target = deployment_target
 
                 # Create Info.plist file for bundle
                 path = target.info_plist_path
                 path.dirname.mkdir unless path.dirname.exist?
                 info_plist_path = path.dirname + "ResourceBundle-#{bundle_name}-#{path.basename}"
-                create_info_plist_file(info_plist_path, bundle_target, target.version, target.platform, :bndl)
+                create_info_plist_file(info_plist_path, resource_bundle_target, target.version, target.platform, :bndl)
 
-                bundle_target.build_configurations.each do |c|
-                  c.build_settings['PRODUCT_NAME'] = bundle_name
+                resource_bundle_target.build_configurations.each do |configuration|
+                  configuration.build_settings['PRODUCT_NAME'] = bundle_name
                   # Do not set the CONFIGURATION_BUILD_DIR for resource bundles that are only meant for test targets.
                   # This is because the test target itself also does not set this configuration build dir and it expects
                   # all bundles to be copied from the default path.
-                  unless test_specification
-                    c.build_settings['CONFIGURATION_BUILD_DIR'] = target.configuration_build_dir('$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)')
+                  unless file_accessor.spec.test_specification?
+                    configuration.build_settings['CONFIGURATION_BUILD_DIR'] = target.configuration_build_dir('$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)')
+                  end
+
+                  # Set the `SWIFT_VERSION` build setting for resource bundles that could have resources that get
+                  # compiled such as an `xcdatamodeld` file which has 'Swift' as its code generation language.
+                  if contains_compile_phase_refs && target.uses_swift?
+                    configuration.build_settings['SWIFT_VERSION'] = target.swift_version
                   end
 
                   # Set the correct device family for this bundle, based on the platform
@@ -367,21 +404,28 @@ module Pod
                   }
 
                   if (family = device_family_by_platform[target.platform.name])
-                    c.build_settings['TARGETED_DEVICE_FAMILY'] = family
+                    configuration.build_settings['TARGETED_DEVICE_FAMILY'] = family
                   end
                 end
+
+                resource_bundle_target
               end
             end
           end
 
           # Generates the contents of the xcconfig file and saves it to disk.
           #
+          # @param  [PBXNativeTarget] native_target
+          #         the native target to link the xcconfig file into.
+          #
+          # @param  [Array<PBXNativeTarget>] resource_bundle_targets
+          #         the additional resource bundle targets to link the xcconfig file into.
+          #
           # @return [void]
           #
-          def create_xcconfig_file
+          def create_xcconfig_file(native_target, resource_bundle_targets)
             path = target.xcconfig_path
-            xcconfig_gen = Generator::XCConfig::PodXCConfig.new(target)
-            update_changed_file(xcconfig_gen, path)
+            update_changed_file(target.build_settings, path)
             xcconfig_file_ref = add_file_to_support_group(path)
 
             native_target.build_configurations.each do |c|
@@ -389,46 +433,56 @@ module Pod
             end
 
             # also apply the private config to resource bundle targets.
-            apply_xcconfig_file_ref_to_resource_bundle_targets(target.resource_bundle_targets, xcconfig_file_ref)
+            apply_xcconfig_file_ref_to_resource_bundle_targets(resource_bundle_targets, xcconfig_file_ref)
           end
 
           # Generates the contents of the xcconfig file used for each test target type and saves it to disk.
           #
+          # @param  [Array<PBXNativeTarget>] test_native_targets
+          #         the test native target to link the xcconfig file into.
+          #
+          # @param  [Hash{String=>Array<PBXNativeTarget>}] test_resource_bundle_targets
+          #         the additional test resource bundle targets to link the xcconfig file into.
+          #
           # @return [void]
           #
-          def create_test_xcconfig_files
-            target.supported_test_types.each do |test_type|
-              path = target.xcconfig_path(test_type.to_s)
-              xcconfig_gen = Generator::XCConfig::PodXCConfig.new(target, true)
-              update_changed_file(xcconfig_gen, path)
-              xcconfig_file_ref = add_file_to_support_group(path)
-
-              target.test_native_targets.each do |test_target|
-                test_target.build_configurations.each do |test_target_bc|
-                  test_target_swift_debug_hack(test_target_bc)
-                  test_target_bc.base_configuration_reference = xcconfig_file_ref
-                end
+          def create_test_xcconfig_files(test_native_targets, test_resource_bundle_targets)
+            target.test_specs.each do |test_spec|
+              spec_consumer = test_spec.consumer(target.platform)
+              test_type = spec_consumer.test_type
+              path = target.xcconfig_path("#{test_type.capitalize}-#{test_spec.name.split('/')[1..-1].join('-')}")
+              update_changed_file(Target::BuildSettings::PodTargetSettings.new(target, test_spec), path)
+              test_xcconfig_file_ref = add_file_to_support_group(path)
+
+              test_native_target = test_native_target_from_spec_consumer(spec_consumer, test_native_targets)
+              test_native_target.build_configurations.each do |test_native_target_bc|
+                test_target_swift_debug_hack(test_spec, test_native_target_bc)
+                test_native_target_bc.base_configuration_reference = test_xcconfig_file_ref
               end
 
-              # also apply the private config to resource bundle test targets.
-              apply_xcconfig_file_ref_to_resource_bundle_targets(target.test_resource_bundle_targets, xcconfig_file_ref)
+              # also apply the private config to resource bundle test targets related to this test spec.
+              scoped_test_resource_bundle_targets = test_resource_bundle_targets[test_spec.name]
+              unless scoped_test_resource_bundle_targets.empty?
+                apply_xcconfig_file_ref_to_resource_bundle_targets(scoped_test_resource_bundle_targets, test_xcconfig_file_ref)
+              end
             end
           end
 
           # Creates a script that copies the resources to the bundle of the test target.
           #
-          # @param [Symbol] test_type
-          #        The test type to create the script for.
+          # @param [Specification] test_spec
+          #        The test spec to create the copy resources script for.
           #
           # @return [void]
           #
-          def create_test_target_copy_resources_script(test_type)
-            path = target.copy_resources_script_path_for_test_type(test_type)
-            pod_targets = target.all_dependent_targets
+          def create_test_target_copy_resources_script(test_spec)
+            path = target.copy_resources_script_path_for_test_spec(test_spec)
+            pod_targets = target.dependent_targets_for_test_spec(test_spec)
             resource_paths_by_config = target.user_build_configurations.keys.each_with_object({}) do |config, resources_by_config|
               resources_by_config[config] = pod_targets.flat_map do |pod_target|
-                include_test_spec_paths = pod_target == target
-                pod_target.resource_paths(include_test_spec_paths)
+                spec_paths_to_include = pod_target.non_test_specs.map(&:name)
+                spec_paths_to_include << test_spec.name if pod_target == target
+                pod_target.resource_paths.values_at(*spec_paths_to_include).flatten.compact
               end
             end
             generator = Generator::CopyResourcesScript.new(resource_paths_by_config, target.platform)
@@ -438,18 +492,19 @@ module Pod
 
           # Creates a script that embeds the frameworks to the bundle of the test target.
           #
-          # @param [Symbol] test_type
-          #        The test type to create the script for.
+          # @param [Specification] test_spec
+          #        The test spec to create the embed frameworks script for.
           #
           # @return [void]
           #
-          def create_test_target_embed_frameworks_script(test_type)
-            path = target.embed_frameworks_script_path_for_test_type(test_type)
-            pod_targets = target.all_dependent_targets
+          def create_test_target_embed_frameworks_script(test_spec)
+            path = target.embed_frameworks_script_path_for_test_spec(test_spec)
+            pod_targets = target.dependent_targets_for_test_spec(test_spec)
             framework_paths_by_config = target.user_build_configurations.keys.each_with_object({}) do |config, paths_by_config|
               paths_by_config[config] = pod_targets.flat_map do |pod_target|
-                include_test_spec_paths = pod_target == target
-                pod_target.framework_paths(include_test_spec_paths)
+                spec_paths_to_include = pod_target.non_test_specs.map(&:name)
+                spec_paths_to_include << test_spec.name if pod_target == target
+                pod_target.framework_paths.values_at(*spec_paths_to_include).flatten.compact.uniq
               end
             end
             generator = Generator::EmbedFrameworksScript.new(framework_paths_by_config)
@@ -462,9 +517,9 @@ module Pod
           #
           # @return [void]
           #
-          def test_target_swift_debug_hack(test_target_bc)
+          def test_target_swift_debug_hack(test_spec, test_target_bc)
             return unless test_target_bc.debug?
-            return unless target.all_dependent_targets.any?(&:uses_swift?)
+            return unless target.dependent_targets_for_test_spec(test_spec).any?(&:uses_swift?)
             ldflags = test_target_bc.build_settings['OTHER_LDFLAGS'] ||= '$(inherited)'
             ldflags << ' -lswiftSwiftOnoneSupport'
           end
@@ -476,9 +531,12 @@ module Pod
           # header_mappings_dir interferes with xcodebuild's expectations
           # about the existence of private or public headers.
           #
+          # @param  [PBXNativeTarget] native_target
+          #         the native target to add the script phase into.
+          #
           # @return [void]
           #
-          def create_build_phase_to_symlink_header_folders
+          def create_build_phase_to_symlink_header_folders(native_target)
             return unless target.platform.name == :osx && header_mappings_dir
 
             build_phase = native_target.new_shell_script_build_phase('Create Symlinks to Header Folders')
@@ -502,7 +560,7 @@ module Pod
           # @param [Platform] platform
           #        the platform to use for this prefix header.
           #
-          # @param [Array<PBXNativetarget>] native_targets
+          # @param [Array<PBXNativeTarget>] native_targets
           #        the native targets on which the prefix header should be configured for.
           #
           # @return [void]
@@ -587,10 +645,10 @@ module Pod
             end
           end
 
-          def create_module_map
-            return super unless custom_module_map
+          def create_module_map(native_target)
+            return super(native_target) unless custom_module_map
 
-            path = target.module_map_path
+            path = target.module_map_path_to_write
             UI.message "- Copying module map file to #{UI.path(path)}" do
               contents = custom_module_map.read
               unless target.requires_frameworks?
@@ -600,17 +658,23 @@ module Pod
               update_changed_file(generator, path)
               add_file_to_support_group(path)
 
+              linked_path = target.module_map_path
+              if path != linked_path
+                linked_path.dirname.mkpath
+                FileUtils.ln_sf(path, linked_path)
+              end
+
+              relative_path = target.module_map_path.relative_path_from(sandbox.root).to_s
               native_target.build_configurations.each do |c|
-                relative_path = path.relative_path_from(sandbox.root)
                 c.build_settings['MODULEMAP_FILE'] = relative_path.to_s
               end
             end
           end
 
           def module_map_additional_headers
-            return [] unless umbrella_headers_by_dir
+            return [] unless umbrella_header_paths
 
-            other_paths = umbrella_headers_by_dir[target.module_map_path.dirname] - [target.umbrella_header_path]
+            other_paths = umbrella_header_paths - [target.umbrella_header_path]
             other_paths.map do |module_map_path|
               # exclude other targets umbrella headers, to avoid
               # incomplete umbrella warnings
@@ -618,8 +682,8 @@ module Pod
             end
           end
 
-          def create_umbrella_header
-            return super unless custom_module_map
+          def create_umbrella_header(native_target)
+            return super(native_target) unless custom_module_map
           end
 
           def custom_module_map
@@ -675,15 +739,59 @@ module Pod
             project.pod_support_files_group(pod_name, dir)
           end
 
+          # @param [String] name
+          #        The name of the app host.
+
+          # @param [Symbol] test_type
+          #        The test type this Info.plist path is for.
+          #
+          # @return [Pathname] The absolute path of the Info.plist to use for an app host.
+          #
+          def app_host_info_plist_path_for_test_type(name, test_type)
+            project.path.dirname.+("#{name}/#{target.app_host_label(test_type)}-Info.plist")
+          end
+
+          def test_native_target_from_spec_consumer(spec_consumer, test_native_targets)
+            test_native_targets.find do |test_native_target|
+              test_native_target.name == target.test_target_label(spec_consumer.spec)
+            end
+          end
+
+          # Adds a placeholder native target for the library to the Pods project with the
+          # appropriate build configurations.
+          #
+          # @return [PBXAggregateTarget] the native target that was added.
+          #
+          def add_placeholder_target
+            native_target = project.new_aggregate_target(target.label, [], target.platform.name, deployment_target)
+            target.user_build_configurations.each do |bc_name, type|
+              native_target.add_build_configuration(bc_name, type)
+            end
+            unless target.archs.empty?
+              native_target.build_configurations.each do |configuration|
+                configuration.build_settings['ARCHS'] = target.archs
+              end
+            end
+            native_target
+          end
+
           # Adds a shell script phase, intended only for static library targets that contain swift,
           # to copy the ObjC compatibility header (the -Swift.h file that the swift compiler generates)
           # to the built products directory. Additionally, the script phase copies the module map, appending a `.Swift`
           # submodule that references the (moved) compatibility header. Since the module map has been moved, the umbrella header
           # is _also_ copied, so that it is sitting next to the module map. This is necessary for a successful archive build.
           #
+          # @param  [PBXNativeTarget] native_target
+          #         the native target to add the Swift static library script phase into.
+          #
           # @return [Void]
           #
-          def add_swift_static_library_compatibility_header_phase
+          def add_swift_static_library_compatibility_header_phase(native_target)
+            if custom_module_map
+              raise Informative, 'Using Swift static libraries with custom module maps is currently not supported. ' \
+                                 "Please build `#{target.label}` as a framework or remove the custom module map."
+            end
+
             build_phase = native_target.new_shell_script_build_phase('Copy generated compatibility header')
 
             relative_module_map_path = target.module_map_path.relative_path_from(target.sandbox.root)