cocoapods 1.6.2 → 1.7.0.beta.1

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

@@ -31,37 +31,43 @@ module Pod
           def install!
             UI.message "- Installing target `#{target.name}` #{target.platform}" do
               create_support_files_dir
-              test_file_accessors, file_accessors = target.file_accessors.partition { |fa| fa.spec.test_specification? }
+              library_file_accessors = target.file_accessors.select { |fa| fa.spec.library_specification? }
+              test_file_accessors = target.file_accessors.select { |fa| fa.spec.test_specification? }
+              app_file_accessors = target.file_accessors.select { |fa| fa.spec.app_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
+                resource_bundle_targets = add_resources_bundle_targets(library_file_accessors).values.flatten
                 create_xcconfig_file(native_target, resource_bundle_targets)
                 return TargetInstallationResult.new(target, native_target, resource_bundle_targets)
               end
 
               native_target = add_target
-              resource_bundle_targets = add_resources_bundle_targets(file_accessors).values.flatten
+              resource_bundle_targets = add_resources_bundle_targets(library_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)
-              validate_targets_contain_sources(test_native_targets + [native_target])
+              app_native_targets = add_app_targets
+              app_resource_bundle_targets = add_resources_bundle_targets(app_file_accessors)
+
+              add_files_to_build_phases(native_target, test_native_targets, app_native_targets)
+              validate_targets_contain_sources(test_native_targets + app_native_targets + [native_target])
 
               create_xcconfig_file(native_target, resource_bundle_targets)
               create_test_xcconfig_files(test_native_targets, test_resource_bundle_targets)
+              create_app_xcconfig_files(app_native_targets, app_resource_bundle_targets)
 
               if target.defines_module?
                 create_module_map(native_target) do |generator|
                   generator.headers.concat module_map_additional_headers
                 end
                 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
+                  generator.imports += library_file_accessors.flat_map do |file_accessor|
+                    header_dir = if !target.build_as_framework? && dir = file_accessor.spec_consumer.header_dir
                                    Pathname.new(dir)
                     end
 
@@ -80,36 +86,82 @@ module Pod
                 end
               end
 
-              if target.requires_frameworks?
+              if target.build_as_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(native_target)
-              elsif target.uses_swift?
-                add_swift_static_library_compatibility_header_phase(native_target)
               end
 
-              unless skip_pch?(target.non_test_specs)
+              if target.build_as_library? && target.uses_swift?
+                add_swift_library_compatibility_header_phase(native_target)
+              end
+
+              project_directory = project.path.dirname
+
+              unless skip_pch?(target.library_specs)
                 path = target.prefix_header_path
-                create_prefix_header(path, file_accessors, target.platform, native_target)
+                create_prefix_header(path, library_file_accessors, target.platform, native_target, project_directory)
+                add_file_to_support_group(path)
               end
               unless skip_pch?(target.test_specs)
                 target.test_specs.each do |test_spec|
-                  path = target.prefix_header_path_for_test_spec(test_spec)
+                  path = target.prefix_header_path_for_spec(test_spec)
                   test_spec_consumer = test_spec.consumer(target.platform)
-                  test_native_target = test_native_target_from_spec_consumer(test_spec_consumer, test_native_targets)
-                  create_prefix_header(path, test_file_accessors, target.platform, test_native_target)
+                  test_native_target = test_native_target_from_spec(test_spec_consumer.spec, test_native_targets)
+                  create_prefix_header(path, test_file_accessors, target.platform, test_native_target, project_directory)
+                  add_file_to_support_group(path)
+                end
+              end
+              unless skip_pch?(target.app_specs)
+                target.app_specs.each do |app_spec|
+                  path = target.prefix_header_path_for_spec(app_spec)
+                  app_spec_consumer = app_spec.consumer(target.platform)
+                  app_native_target = app_native_target_from_spec(app_spec_consumer.spec, app_native_targets)
+                  create_prefix_header(path, app_file_accessors, target.platform, app_native_target, project_directory)
+                  add_file_to_support_group(path)
                 end
               end
               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)
+              TargetInstallationResult.new(target, native_target, resource_bundle_targets,
+                                           test_native_targets, test_resource_bundle_targets, test_app_host_targets,
+                                           app_native_targets, app_resource_bundle_targets)
             end
           end
 
           private
 
+          # Adds the target for the library to the Pods project with the
+          # appropriate build configurations.
+          #
+          # @note   Overrides the superclass implementation to remove settings that are set in the pod target xcconfig
+          #
+          # @return [PBXNativeTarget] the native target that was added.
+          #
+          def add_target
+            super.tap do |native_target|
+              remove_pod_target_xcconfig_overrides_from_target(target.build_settings, native_target)
+            end
+          end
+
+          # Removes overrides of the `pod_target_xcconfig` settings from the target's
+          # build configurations.
+          #
+          # @return [Void]
+          #
+          # @param [Target::BuildSettings] build_settings
+          #
+          # @param [PBXNativeTarget] native_target
+          #
+          def remove_pod_target_xcconfig_overrides_from_target(build_settings, native_target)
+            native_target.build_configurations.each do |configuration|
+              build_settings.merged_pod_target_xcconfigs.each_key do |setting|
+                configuration.build_settings.delete(setting)
+              end
+            end
+          end
+
           # @param [Array<Specification>] specs
           #        the specs to check against whether `.pch` generation should be skipped or not.
           #
@@ -137,7 +189,7 @@ module Pod
           #
           def custom_build_settings
             settings = super
-            unless target.requires_frameworks?
+            unless target.build_as_framework?
               settings['PRIVATE_HEADERS_FOLDER_PATH'] = ''
               settings['PUBLIC_HEADERS_FOLDER_PATH'] = ''
             end
@@ -195,9 +247,8 @@ module Pod
               ref
             end.compact.uniq
             compile_phase_matcher = lambda { |ref| !(ref.path =~ /.*\.xcdatamodeld/i).nil? }
-            resources_phase_refs = file_references.reject(&compile_phase_matcher)
-            compile_phase_refs = file_references.select(&compile_phase_matcher)
-            yield resources_phase_refs, compile_phase_refs
+            compile_phase_refs, resources_phase_refs = file_references.partition(&compile_phase_matcher)
+            yield compile_phase_refs, resources_phase_refs
           end
 
           #-----------------------------------------------------------------------#
@@ -215,15 +266,18 @@ module Pod
           #
           # @return [void]
           #
-          def add_files_to_build_phases(native_target, test_native_targets)
+          def add_files_to_build_phases(native_target, test_native_targets, app_native_targets)
             target.file_accessors.each do |file_accessor|
               consumer = file_accessor.spec_consumer
 
-              native_target = if !consumer.spec.test_specification?
-                                native_target
-                              else
-                                test_native_target_from_spec_consumer(consumer, test_native_targets)
-                              end
+              native_target =  case consumer.spec.spec_type
+                               when :library
+                                 native_target
+                               when :test
+                                 test_native_target_from_spec(consumer.spec, test_native_targets)
+                               when :app
+                                 app_native_target_from_spec(consumer.spec, app_native_targets)
+                               end
 
               headers = file_accessor.headers
               public_headers = file_accessor.public_headers.map(&:realpath)
@@ -249,9 +303,9 @@ module Pod
               other_file_refs = project_file_references_array(other_source_files, 'other source')
               native_target.add_file_references(other_file_refs, nil)
 
-              next unless target.requires_frameworks?
+              next unless target.build_as_dynamic_framework?
 
-              filter_resource_file_references(file_accessor.resources.flatten) do |resource_phase_refs, compile_phase_refs|
+              filter_resource_file_references(file_accessor.resources.flatten) do |compile_phase_refs, resource_phase_refs|
                 native_target.add_file_references(compile_phase_refs, nil)
                 native_target.add_resources(resource_phase_refs)
               end
@@ -270,7 +324,7 @@ module Pod
               product_type = target.product_type_for_test_type(test_type)
               name = target.test_target_label(test_spec)
               platform_name = target.platform.name
-              language = target.uses_swift_for_test_spec?(test_spec) ? :swift : :objc
+              language = target.uses_swift_for_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
 
@@ -303,6 +357,8 @@ module Pod
                 configuration.build_settings['CODE_SIGN_IDENTITY'] = '' if target.platform == :osx
               end
 
+              remove_pod_target_xcconfig_overrides_from_target(target.build_settings_for_spec(test_spec), test_native_target)
+
               # Test native targets also need frameworks and resources to be copied over to their xctest bundle.
               create_test_target_embed_frameworks_script(test_spec)
               create_test_target_copy_resources_script(test_spec)
@@ -310,7 +366,7 @@ module Pod
               # 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_spec(test_spec), test_native_target, '1.0', target.platform, :bndl)
+              create_info_plist_file(target.info_plist_path_for_spec(test_spec), test_native_target, '1.0', target.platform, :bndl)
 
               test_native_target
             end
@@ -328,10 +384,10 @@ module Pod
             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, target.pod_name).install!
+              app_host_target = AppHostInstaller.new(sandbox, project, platform, name, target.pod_name, 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 = test_native_target_from_spec(test_spec_consumer.spec, 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
@@ -347,6 +403,79 @@ module Pod
             end
           end
 
+          # Adds the app targets for the library to the Pods project with the
+          # appropriate build configurations.
+          #
+          # @return [Array<PBXNativeTarget>] the app native targets created.
+          #
+          def add_app_targets
+            target.app_specs.map do |app_spec|
+              spec_name = app_spec.parent.name
+              subspec_name = target.subspec_label(app_spec)
+              app_target_label = target.app_target_label(app_spec)
+              platform = target.platform
+              app_native_target = AppHostInstaller.new(sandbox, project, platform, subspec_name, spec_name,
+                                                       app_target_label, :add_main => false).install!
+
+              app_native_target.product_reference.name = app_target_label
+              target.user_build_configurations.each do |bc_name, type|
+                app_native_target.add_build_configuration(bc_name, type)
+              end
+
+              app_native_target.build_configurations.each do |configuration|
+                configuration.build_settings.merge!(custom_build_settings)
+
+                # target_installer will automatically add an empty `OTHER_LDFLAGS`. For app
+                # targets those are set via an app xcconfig file instead.
+                configuration.build_settings.delete('OTHER_LDFLAGS')
+                # target_installer will automatically set the product name to the module name if the target
+                # requires frameworks. For apps we always use the app target name as the product name
+                # irrelevant to whether we use frameworks or not.
+                configuration.build_settings['PRODUCT_NAME'] = app_target_label
+                # target_installer sets 'MACH_O_TYPE' for static frameworks ensure this does not propagate
+                # to app target.
+                configuration.build_settings.delete('MACH_O_TYPE')
+                # Use xcode default product module name, which is $(PRODUCT_NAME:c99extidentifier)
+                # this gives us always valid name that is distinct from the parent spec module name
+                # which allow the app to use import to access the parent framework
+                configuration.build_settings.delete('PRODUCT_MODULE_NAME')
+
+                # We must codesign iOS app bundles that contain binary frameworks to allow them to be launchable in the simulator
+                unless target.platform == :osx
+                  configuration.build_settings['CODE_SIGNING_REQUIRED'] = 'YES'
+                  configuration.build_settings['CODE_SIGNING_ALLOWED'] = 'YES'
+                end
+                # For macOS we do not code sign the appbundle because we do not code sign the frameworks either.
+                configuration.build_settings['CODE_SIGN_IDENTITY'] = '' if target.platform == :osx
+              end
+
+              remove_pod_target_xcconfig_overrides_from_target(target.build_settings_for_spec(app_spec), app_native_target)
+
+              create_app_target_embed_frameworks_script(app_spec)
+              create_app_target_copy_resources_script(app_spec)
+              add_resources_to_target(target.file_accessors.find { |fa| fa.spec == app_spec }.resources, app_native_target)
+
+              app_native_target
+            end
+          end
+
+          # Adds the resources to the compile resources phase of the target.
+          #
+          # @param  [Array<Pathname>] paths the paths to add to the target.
+          #
+          # @param  [PBXNativeTarget] target the target resources are added to.
+          #
+          # @return [Boolean] whether any compile phase references were added.
+          #
+          def add_resources_to_target(paths, target)
+            filter_resource_file_references(paths) do |compile_phase_refs, resource_phase_refs|
+              # Resource bundles are only meant to have resources, so install everything
+              # into the resources phase. See note in filter_resource_file_references.
+              target.add_resources(resource_phase_refs + compile_phase_refs)
+              !compile_phase_refs.empty?
+            end
+          end
+
           # Adds the resources of the Pods to the Pods project.
           #
           # @note   The source files are grouped by Pod and in turn by subspec
@@ -355,7 +484,7 @@ module Pod
           # @param  [Array<Sandbox::FileAccessor>] file_accessors
           #         the file accessors list to generate resource bundles for.
           #
-          # @return [Array<PBXNativeTarget] the resource bundle native targets created.
+          # @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|
@@ -367,13 +496,7 @@ module Pod
                   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.
-                  resource_bundle_target.add_resources(resource_phase_refs + compile_phase_refs)
-                  contains_compile_phase_refs = !compile_phase_refs.empty?
-                end
+                contains_compile_phase_refs = add_resources_to_target(paths, resource_bundle_target)
 
                 target.user_build_configurations.each do |bc_name, type|
                   resource_bundle_target.add_build_configuration(bc_name, type)
@@ -397,7 +520,7 @@ module Pod
 
                   # 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?
+                  if contains_compile_phase_refs && file_accessors.any? { |fa| target.uses_swift_for_spec?(fa.spec) }
                     configuration.build_settings['SWIFT_VERSION'] = target.swift_version
                   end
 
@@ -413,6 +536,8 @@ module Pod
                   end
                 end
 
+                remove_pod_target_xcconfig_overrides_from_target(target.build_settings_for_spec(file_accessor.spec), resource_bundle_target)
+
                 resource_bundle_target
               end
             end
@@ -433,12 +558,8 @@ module Pod
             update_changed_file(target.build_settings, path)
             xcconfig_file_ref = add_file_to_support_group(path)
 
-            native_target.build_configurations.each do |c|
-              c.base_configuration_reference = xcconfig_file_ref
-            end
-
             # also apply the private config to resource bundle targets.
-            apply_xcconfig_file_ref_to_resource_bundle_targets(resource_bundle_targets, xcconfig_file_ref)
+            apply_xcconfig_file_ref_to_targets([native_target] + 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.
@@ -455,21 +576,19 @@ module Pod
             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)
+              path = target.xcconfig_path("#{test_type.capitalize}-#{target.subspec_label(test_spec)}")
+              test_spec_build_settings = target.build_settings_for_spec(test_spec)
+              update_changed_file(test_spec_build_settings, 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 = test_native_target_from_spec(spec_consumer.spec, 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 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
+              apply_xcconfig_file_ref_to_targets([test_native_target] + scoped_test_resource_bundle_targets, test_xcconfig_file_ref)
             end
           end
 
@@ -481,11 +600,11 @@ module Pod
           # @return [void]
           #
           def create_test_target_copy_resources_script(test_spec)
-            path = target.copy_resources_script_path_for_test_spec(test_spec)
+            path = target.copy_resources_script_path_for_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|
-                spec_paths_to_include = pod_target.non_test_specs.map(&:name)
+                spec_paths_to_include = pod_target.library_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
@@ -503,11 +622,11 @@ module Pod
           # @return [void]
           #
           def create_test_target_embed_frameworks_script(test_spec)
-            path = target.embed_frameworks_script_path_for_test_spec(test_spec)
+            path = target.embed_frameworks_script_path_for_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|
-                spec_paths_to_include = pod_target.non_test_specs.map(&:name)
+                spec_paths_to_include = pod_target.library_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
@@ -517,6 +636,75 @@ module Pod
             add_file_to_support_group(path)
           end
 
+          # Generates the contents of the xcconfig file used for each app target type and saves it to disk.
+          #
+          # @param  [Array<PBXNativeTarget>] app_native_targets
+          #         the app native target to link the xcconfig file into.
+          #
+          # @param  [Hash{String=>Array<PBXNativeTarget>}] app_resource_bundle_targets
+          #         the additional app resource bundle targets to link the xcconfig file into.
+          #
+          # @return [void]
+          #
+          def create_app_xcconfig_files(app_native_targets, app_resource_bundle_targets)
+            target.app_specs.each do |app_spec|
+              spec_consumer = app_spec.consumer(target.platform)
+              path = target.xcconfig_path(target.subspec_label(app_spec))
+              update_changed_file(target.build_settings_for_spec(app_spec), path)
+              app_xcconfig_file_ref = add_file_to_support_group(path)
+
+              app_native_target = app_native_target_from_spec(spec_consumer.spec, app_native_targets)
+
+              # also apply the private config to resource bundle app targets related to this app spec.
+              scoped_app_resource_bundle_targets = app_resource_bundle_targets[app_spec.name]
+              apply_xcconfig_file_ref_to_targets([app_native_target] + scoped_app_resource_bundle_targets, app_xcconfig_file_ref)
+            end
+          end
+
+          # Creates a script that copies the resources to the bundle of the app target.
+          #
+          # @param [Specification] app_spec
+          #        The app spec to create the copy resources script for.
+          #
+          # @return [void]
+          #
+          def create_app_target_copy_resources_script(app_spec)
+            path = target.copy_resources_script_path_for_spec(app_spec)
+            pod_targets = target.dependent_targets_for_app_spec(app_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|
+                spec_paths_to_include = pod_target.library_specs.map(&:name)
+                spec_paths_to_include << app_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)
+            update_changed_file(generator, path)
+            add_file_to_support_group(path)
+          end
+
+          # Creates a script that embeds the frameworks to the bundle of the app target.
+          #
+          # @param [Specification] app_spec
+          #        The app spec to create the embed frameworks script for.
+          #
+          # @return [void]
+          #
+          def create_app_target_embed_frameworks_script(app_spec)
+            path = target.embed_frameworks_script_path_for_spec(app_spec)
+            pod_targets = target.dependent_targets_for_app_spec(app_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|
+                spec_paths_to_include = pod_target.library_specs.map(&:name)
+                spec_paths_to_include << app_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)
+            update_changed_file(generator, path)
+            add_file_to_support_group(path)
+          end
+
           # Manually add `libswiftSwiftOnoneSupport.dylib` as it seems there is an issue with tests that do not include it for Debug configurations.
           # Possibly related to Swift module optimization.
           #
@@ -552,35 +740,6 @@ module Pod
             eos
           end
 
-          # Creates a prefix header file which imports `UIKit` or `Cocoa` according
-          # to the platform of the target. This file also include any prefix header
-          # content reported by the specification of the pods.
-          #
-          # @param [Pathname] path
-          #        the path to generate the prefix header for.
-          #
-          # @param [Array<Sandbox::FileAccessor>] file_accessors
-          #        the file accessors to use for this prefix header that point to a path of a prefix header.
-          #
-          # @param [Platform] platform
-          #        the platform to use for this prefix header.
-          #
-          # @param [PBXNativeTarget] native_target
-          #        the native target on which the prefix header should be configured for.
-          #
-          # @return [void]
-          #
-          def create_prefix_header(path, file_accessors, platform, native_target)
-            generator = Generator::PrefixHeader.new(file_accessors, platform)
-            update_changed_file(generator, path)
-            add_file_to_support_group(path)
-
-            relative_path = path.relative_path_from(project.path.dirname)
-            native_target.build_configurations.each do |c|
-              c.build_settings['GCC_PREFIX_HEADER'] = relative_path.to_s
-            end
-          end
-
           ENABLE_OBJECT_USE_OBJC_FROM = {
             :ios => Version.new('6'),
             :osx => Version.new('10.8'),
@@ -615,7 +774,7 @@ module Pod
           #   **Note:** libraries that do *not* specify a platform version are
           #             assumed to have a deployment target of < iOS 6.0 or OS X 10.8.
           #
-          #  For more information, see: http://opensource.apple.com/source/libdispatch/libdispatch-228.18/os/object.h
+          #  For more information, see: https://opensource.apple.com/source/libdispatch/libdispatch-228.18/os/object.h
           #
           # @param  [Specification::Consumer] consumer
           #         The consumer for the specification for which the compiler flags
@@ -640,10 +799,10 @@ module Pod
             flags * ' '
           end
 
-          def apply_xcconfig_file_ref_to_resource_bundle_targets(resource_bundle_targets, xcconfig_file_ref)
-            resource_bundle_targets.each do |rsrc_target|
-              rsrc_target.build_configurations.each do |rsrc_bc|
-                rsrc_bc.base_configuration_reference = xcconfig_file_ref
+          def apply_xcconfig_file_ref_to_targets(targets, xcconfig_file_ref)
+            targets.each do |config_target|
+              config_target.build_configurations.each do |configuration|
+                configuration.base_configuration_reference = xcconfig_file_ref
               end
             end
           end
@@ -654,7 +813,7 @@ module Pod
             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?
+              unless target.build_as_framework?
                 contents.gsub!(/^(\s*)framework\s+(module[^{}]+){/, '\1\2{')
               end
               generator = Generator::Constant.new(contents)
@@ -712,7 +871,7 @@ module Pod
 
           def add_header(build_file, public_headers, private_headers, native_target)
             file_ref = build_file.file_ref
-            acl = if !target.requires_frameworks? # Headers are already rooted at ${PODS_ROOT}/Headers/P*/[pod]/...
+            acl = if !target.build_as_framework? # Headers are already rooted at ${PODS_ROOT}/Headers/P*/[pod]/...
                     'Project'
                   elsif public_headers.include?(file_ref.real_path)
                     'Public'
@@ -722,7 +881,7 @@ module Pod
                     'Project'
                   end
 
-            if target.requires_frameworks? && header_mappings_dir && acl != 'Project'
+            if target.build_as_framework? && header_mappings_dir && acl != 'Project'
               relative_path = file_ref.real_path.relative_path_from(header_mappings_dir)
               sub_dir = relative_path.dirname
               copy_phase_name = "Copy #{sub_dir} #{acl} Headers"
@@ -743,21 +902,17 @@ 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")
+          def test_native_target_from_spec(spec, test_native_targets)
+            test_target_label = target.test_target_label(spec)
+            test_native_targets.find do |test_native_target|
+              test_native_target.name == test_target_label
+            end
           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)
+          def app_native_target_from_spec(spec, app_native_targets)
+            app_target_label = target.app_target_label(spec)
+            app_native_targets.find do |app_native_target|
+              app_native_target.name == app_target_label
             end
           end
 
@@ -779,7 +934,7 @@ module Pod
             native_target
           end
 
-          # Adds a shell script phase, intended only for static library targets that contain swift,
+          # Adds a shell script phase, intended only for 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
@@ -790,7 +945,7 @@ module Pod
           #
           # @return [Void]
           #
-          def add_swift_static_library_compatibility_header_phase(native_target)
+          def add_swift_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."