cocoapods-tt 0.0.1

data/lib/cocoapods-tt/native/installer/xcode/pods_project_generator/pod_target_integrator.rb

@@ -0,0 +1,312 @@
+module Pod
+  class Installer
+    class Xcode
+      class PodsProjectGenerator
+        # This class is responsible for integrating a pod target. This includes integrating
+        # the test targets included by each pod target.
+        #
+        class PodTargetIntegrator
+          # @return [TargetInstallationResult] the installation result of the target that should be integrated.
+          #
+          attr_reader :target_installation_result
+
+          # @return [Boolean] whether to use input/output paths for build phase scripts
+          #
+          attr_reader :use_input_output_paths
+          alias use_input_output_paths? use_input_output_paths
+
+          # Initialize a new instance
+          #
+          # @param  [TargetInstallationResult] target_installation_result @see #target_installation_result
+          # @param  [Boolean] use_input_output_paths @see #use_input_output_paths
+          #
+          def initialize(target_installation_result, use_input_output_paths: true)
+            @target_installation_result = target_installation_result
+            @use_input_output_paths = use_input_output_paths
+          end
+
+          # Integrates the pod target.
+          #
+          # @return [void]
+          #
+          def integrate!
+            UI.section(integration_message) do
+              target_installation_result.non_library_specs_by_native_target.each do |native_target, spec|
+                add_embed_frameworks_script_phase(native_target, spec)
+                add_copy_resources_script_phase(native_target, spec)
+                add_on_demand_resources(native_target, spec) if spec.app_specification?
+                UserProjectIntegrator::TargetIntegrator.create_or_update_user_script_phases(script_phases_for_specs(spec), native_target)
+              end
+              add_copy_dsyms_script_phase(target_installation_result.native_target)
+              add_copy_xcframeworks_script_phase(target_installation_result.native_target)
+              UserProjectIntegrator::TargetIntegrator.create_or_update_user_script_phases(script_phases_for_specs(target.library_specs), target_installation_result.native_target)
+            end
+          end
+
+          # @return [String] a string representation suitable for debugging.
+          #
+          def inspect
+            "#<#{self.class} for target `#{target.label}'>"
+          end
+
+          private
+
+          # @!group Integration steps
+          #---------------------------------------------------------------------#
+
+          # Find or create a 'Copy Pods Resources' build phase
+          #
+          # @param [PBXNativeTarget] native_target
+          #         the native target for which to add the copy resources script
+          #
+          # @param [Pod::Specification] spec
+          #         the specification to integrate
+          #
+          # @return [void]
+          #
+          def add_copy_resources_script_phase(native_target, spec)
+            script_path = "${PODS_ROOT}/#{target.copy_resources_script_path_for_spec(spec).relative_path_from(target.sandbox.root)}"
+
+            input_paths_by_config = {}
+            output_paths_by_config = {}
+
+            dependent_targets = if spec.test_specification?
+                                  target.dependent_targets_for_test_spec(spec)
+                                else
+                                  target.dependent_targets_for_app_spec(spec)
+                                end
+            host_target_spec_names = target.app_host_dependent_targets_for_spec(spec).flat_map do |pt|
+              pt.specs.map(&:name)
+            end.uniq
+            resource_paths = dependent_targets.flat_map do |dependent_target|
+              spec_paths_to_include = dependent_target.library_specs.map(&:name)
+              spec_paths_to_include -= host_target_spec_names
+              spec_paths_to_include << spec.name if dependent_target == target
+              dependent_target.resource_paths.values_at(*spec_paths_to_include).flatten.compact
+            end.uniq
+
+            if use_input_output_paths? && !resource_paths.empty?
+              input_file_list_path = target.copy_resources_script_input_files_path_for_spec(spec)
+              input_file_list_relative_path = "${PODS_ROOT}/#{input_file_list_path.relative_path_from(target.sandbox.root)}"
+              input_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(input_file_list_path, input_file_list_relative_path)
+              input_paths_by_config[input_paths_key] = [script_path] + resource_paths
+
+              output_file_list_path = target.copy_resources_script_output_files_path_for_spec(spec)
+              output_file_list_relative_path = "${PODS_ROOT}/#{output_file_list_path.relative_path_from(target.sandbox.root)}"
+              output_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(output_file_list_path, output_file_list_relative_path)
+              output_paths_by_config[output_paths_key] = UserProjectIntegrator::TargetIntegrator.resource_output_paths(resource_paths)
+            end
+
+            if resource_paths.empty?
+              UserProjectIntegrator::TargetIntegrator.remove_copy_resources_script_phase_from_target(native_target)
+            else
+              UserProjectIntegrator::TargetIntegrator.create_or_update_copy_resources_script_phase_to_target(
+                native_target, script_path, input_paths_by_config, output_paths_by_config)
+            end
+          end
+
+          # Find or create a 'Embed Pods Frameworks' Run Script Build Phase
+          #
+          # @param [PBXNativeTarget] native_target
+          #         the native target for which to add the embed frameworks script
+          #
+          # @param [Pod::Specification] spec
+          #         the specification to integrate
+          #
+          # @return [void]
+          #
+          def add_embed_frameworks_script_phase(native_target, spec)
+            script_path = "${PODS_ROOT}/#{target.embed_frameworks_script_path_for_spec(spec).relative_path_from(target.sandbox.root)}"
+
+            input_paths_by_config = {}
+            output_paths_by_config = {}
+
+            dependent_targets = if spec.test_specification?
+                                  target.dependent_targets_for_test_spec(spec)
+                                else
+                                  target.dependent_targets_for_app_spec(spec)
+                                end
+            host_target_spec_names = target.app_host_dependent_targets_for_spec(spec).flat_map do |pt|
+              pt.specs.map(&:name)
+            end.uniq
+            framework_paths = dependent_targets.flat_map do |dependent_target|
+              spec_paths_to_include = dependent_target.library_specs.map(&:name)
+              spec_paths_to_include -= host_target_spec_names
+              spec_paths_to_include << spec.name if dependent_target == target
+              dependent_target.framework_paths.values_at(*spec_paths_to_include).flatten.compact
+            end.uniq
+            xcframework_paths = dependent_targets.flat_map do |dependent_target|
+              spec_paths_to_include = dependent_target.library_specs.map(&:name)
+              spec_paths_to_include -= host_target_spec_names
+              spec_paths_to_include << spec.name if dependent_target == target
+              dependent_target.xcframeworks.values_at(*spec_paths_to_include).flatten.compact
+            end.uniq
+
+            if use_input_output_paths? && !framework_paths.empty? || !xcframework_paths.empty?
+              input_file_list_path = target.embed_frameworks_script_input_files_path_for_spec(spec)
+              input_file_list_relative_path = "${PODS_ROOT}/#{input_file_list_path.relative_path_from(target.sandbox.root)}"
+              input_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(input_file_list_path, input_file_list_relative_path)
+              input_paths_by_config[input_paths_key] = [script_path] + UserProjectIntegrator::TargetIntegrator.embed_frameworks_input_paths(framework_paths, xcframework_paths)
+
+              output_file_list_path = target.embed_frameworks_script_output_files_path_for_spec(spec)
+              output_file_list_relative_path = "${PODS_ROOT}/#{output_file_list_path.relative_path_from(target.sandbox.root)}"
+              output_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(output_file_list_path, output_file_list_relative_path)
+              output_paths_by_config[output_paths_key] = UserProjectIntegrator::TargetIntegrator.embed_frameworks_output_paths(framework_paths, xcframework_paths)
+            end
+
+            if framework_paths.empty? && xcframework_paths.empty?
+              UserProjectIntegrator::TargetIntegrator.remove_embed_frameworks_script_phase_from_target(native_target)
+            else
+              UserProjectIntegrator::TargetIntegrator.create_or_update_embed_frameworks_script_phase_to_target(
+                native_target, script_path, input_paths_by_config, output_paths_by_config)
+            end
+          end
+
+          # Find or create a 'Prepare Artifacts' Run Script Build Phase
+          #
+          # @param [PBXNativeTarget] native_target
+          #         the native target for which to add the prepare artifacts script
+          #
+          # @return [void]
+          #
+          def add_copy_xcframeworks_script_phase(native_target)
+            script_path = "${PODS_ROOT}/#{target.copy_xcframeworks_script_path.relative_path_from(target.sandbox.root)}"
+
+            input_paths_by_config = {}
+            output_paths_by_config = {}
+
+            xcframeworks = target.xcframeworks.values.flatten
+
+            if use_input_output_paths? && !xcframeworks.empty?
+              input_file_list_path = target.copy_xcframeworks_script_input_files_path
+              input_file_list_relative_path = "${PODS_ROOT}/#{input_file_list_path.relative_path_from(target.sandbox.root)}"
+              input_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(input_file_list_path, input_file_list_relative_path)
+              input_paths = input_paths_by_config[input_paths_key] = [script_path]
+
+              framework_paths = xcframeworks.map { |xcf| "${PODS_ROOT}/#{xcf.path.relative_path_from(target.sandbox.root)}" }
+              input_paths.concat framework_paths
+
+              output_file_list_path = target.copy_xcframeworks_script_output_files_path
+              output_file_list_relative_path = "${PODS_ROOT}/#{output_file_list_path.relative_path_from(target.sandbox.root)}"
+              output_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(output_file_list_path, output_file_list_relative_path)
+              output_paths_by_config[output_paths_key] = xcframeworks.map do |xcf|
+                "#{Target::BuildSettings::XCFRAMEWORKS_BUILD_DIR_VARIABLE}/#{xcf.target_name}/#{xcf.name}.framework"
+              end
+            end
+
+            if xcframeworks.empty?
+              UserProjectIntegrator::TargetIntegrator.remove_copy_xcframeworks_script_phase_from_target(native_target)
+            else
+              UserProjectIntegrator::TargetIntegrator.create_or_update_copy_xcframeworks_script_phase_to_target(
+                native_target, script_path, input_paths_by_config, output_paths_by_config)
+            end
+          end
+
+          # Adds a script phase that copies and strips dSYMs that are part of this target. Note this only deals with
+          # vendored dSYMs.
+          #
+          # @param [PBXNativeTarget] native_target
+          #         the native target for which to add the copy dSYM files build phase.
+          #
+          # @return [void]
+          #
+          def add_copy_dsyms_script_phase(native_target)
+            script_path = "${PODS_ROOT}/#{target.copy_dsyms_script_path.relative_path_from(target.sandbox.root)}"
+            dsym_paths = PodTargetInstaller.dsym_paths(target)
+            bcsymbolmap_paths = PodTargetInstaller.bcsymbolmap_paths(target)
+
+            if dsym_paths.empty? && bcsymbolmap_paths.empty?
+              script_phase = native_target.shell_script_build_phases.find do |bp|
+                bp.name && bp.name.end_with?(UserProjectIntegrator::TargetIntegrator::COPY_DSYM_FILES_PHASE_NAME)
+              end
+              native_target.build_phases.delete(script_phase) if script_phase.present?
+              return
+            end
+
+            phase_name = UserProjectIntegrator::TargetIntegrator::BUILD_PHASE_PREFIX + UserProjectIntegrator::TargetIntegrator::COPY_DSYM_FILES_PHASE_NAME
+            phase = UserProjectIntegrator::TargetIntegrator.create_or_update_shell_script_build_phase(native_target, phase_name)
+            phase.shell_script = %("#{script_path}"\n)
+
+            input_paths_by_config = {}
+            output_paths_by_config = {}
+            if use_input_output_paths?
+              input_file_list_path = target.copy_dsyms_script_input_files_path
+              input_file_list_relative_path = "${PODS_ROOT}/#{input_file_list_path.relative_path_from(target.sandbox.root)}"
+              input_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(input_file_list_path, input_file_list_relative_path)
+              input_paths = input_paths_by_config[input_paths_key] = []
+              input_paths.concat([dsym_paths, *bcsymbolmap_paths].flatten.compact)
+
+              output_file_list_path = target.copy_dsyms_script_output_files_path
+              output_file_list_relative_path = "${PODS_ROOT}/#{output_file_list_path.relative_path_from(target.sandbox.root)}"
+              output_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(output_file_list_path, output_file_list_relative_path)
+              output_paths = output_paths_by_config[output_paths_key] = []
+
+              dsym_output_paths = dsym_paths.map { |dsym_path| "${DWARF_DSYM_FOLDER_PATH}/#{File.basename(dsym_path)}" }
+              bcsymbolmap_output_paths = bcsymbolmap_paths.map { |bcsymbolmap_path| "${DWARF_DSYM_FOLDER_PATH}/#{File.basename(bcsymbolmap_path)}" }
+              output_paths.concat([dsym_output_paths, *bcsymbolmap_output_paths].flatten.compact)
+            end
+
+            UserProjectIntegrator::TargetIntegrator.set_input_output_paths(phase, input_paths_by_config, output_paths_by_config)
+          end
+
+          # Adds the ODRs that are related to this app spec. This includes the app spec dependencies as well as the ODRs
+          # coming from the app spec itself.
+          #
+          # @param [Xcodeproj::PBXNativeTarget] native_target
+          #         the native target for which to add the ODR file references into.
+          #
+          # @param [Specification] app_spec
+          #         the app spec to integrate ODRs for.
+          #
+          # @return [void]
+          #
+          def add_on_demand_resources(native_target, app_spec)
+            dependent_targets = target.dependent_targets_for_app_spec(app_spec)
+            parent_odr_group = native_target.project.group_for_spec(app_spec.name)
+
+            # Add ODRs of the app spec dependencies first.
+            dependent_targets.each do |pod_target|
+              file_accessors = pod_target.file_accessors.select do |fa|
+                fa.spec.library_specification? ||
+                  fa.spec.test_specification? && pod_target.test_app_hosts_by_spec[fa.spec]&.first == app_spec
+              end
+              target_odr_group_name = "#{pod_target.label}-OnDemandResources"
+              UserProjectIntegrator::TargetIntegrator.update_on_demand_resources(target.sandbox, native_target.project,
+                                                                                 native_target, file_accessors,
+                                                                                 parent_odr_group, target_odr_group_name)
+            end
+
+            # Now add the ODRs of our own app spec declaration.
+            file_accessor = target.file_accessors.find { |fa| fa.spec == app_spec }
+            target_odr_group_name = "#{target.subspec_label(app_spec)}-OnDemandResources"
+            UserProjectIntegrator::TargetIntegrator.update_on_demand_resources(target.sandbox, native_target.project,
+                                                                               native_target, file_accessor,
+                                                                               parent_odr_group, target_odr_group_name)
+          end
+
+          # @return [String] the message that should be displayed for the target
+          #         integration.
+          #
+          def integration_message
+            "Integrating target `#{target.name}`"
+          end
+
+          # @return [PodTarget] the target part of the installation result.
+          #
+          def target
+            target_installation_result.target
+          end
+
+          # @param [Specification, Array<Specification>] specs
+          #         the specs to return script phrases from.
+          #
+          # @return [Array<Hash<Symbol=>String>] an array of all combined script phases from the specs.
+          #
+          def script_phases_for_specs(specs)
+            Array(specs).flat_map { |spec| spec.consumer(target.platform).script_phases }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/installer/xcode/pods_project_generator/pods_project_writer.rb

@@ -0,0 +1,90 @@
+module Pod
+  class Installer
+    class Xcode
+      class PodsProjectWriter
+        # @return [Sandbox] sandbox
+        #         The Pods sandbox instance.
+        #
+        attr_reader :sandbox
+
+        # @return [Array<Project>] projects
+        #         The list project to write.
+        #
+        attr_reader :projects
+
+        # @return [Hash<String, TargetInstallationResult>] pod_target_installation_results
+        #         Hash of pod target name to installation results.
+        #
+        attr_reader :pod_target_installation_results
+
+        # @return [InstallationOptions] installation_options
+        #
+        attr_reader :installation_options
+
+        # Initialize a new instance
+        #
+        # @param [Sandbox] sandbox @see #sandbox
+        # @param [Project] projects @see #project
+        # @param [Hash<String, TargetInstallationResult>] pod_target_installation_results @see #pod_target_installation_results
+        # @param [InstallationOptions] installation_options @see #installation_options
+        #
+        def initialize(sandbox, projects, pod_target_installation_results, installation_options)
+          @sandbox = sandbox
+          @projects = projects
+          @pod_target_installation_results = pod_target_installation_results
+          @installation_options = installation_options
+        end
+
+        # Writes projects to disk.
+        #
+        # @yield If provided, this block will execute right before writing the projects to disk.
+        #
+        def write!
+          cleanup_projects(projects)
+
+          projects.each do |project|
+            library_product_types = [:framework, :dynamic_library, :static_library]
+            results_by_native_target = Hash[pod_target_installation_results.map do |_, result|
+              [result.native_target, result]
+            end]
+            project.recreate_user_schemes(false) do |scheme, target|
+              next unless target.respond_to?(:symbol_type)
+              next unless library_product_types.include? target.symbol_type
+              installation_result = results_by_native_target[target]
+              next unless installation_result
+              installation_result.test_native_targets.each do |test_native_target|
+                scheme.add_test_target(test_native_target)
+              end
+            end
+          end
+
+          yield if block_given?
+
+          save_projects(projects)
+        end
+
+        private
+
+        # Cleans up projects before writing.
+        #
+        def cleanup_projects(projects)
+          projects.each do |project|
+            [project.pods, project.support_files_group,
+             project.development_pods, project.dependencies_group].each { |group| group.remove_from_project if group.empty? }
+          end
+        end
+
+        # Sorts and then saves projects which writes them to disk.
+        #
+        def save_projects(projects)
+          projects.each do |project|
+            project.sort(:groups_position => :below)
+            UI.message "- Writing Xcode project file to #{UI.path project.path}" do
+              project.save
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/installer/xcode/pods_project_generator/project_generator.rb

@@ -0,0 +1,120 @@
+module Pod
+  class Installer
+    class Xcode
+      # Responsible for creating and preparing a Pod::Project instance
+      #
+      class ProjectGenerator
+        # @return [Sandbox] sandbox
+        #         The Pods sandbox instance.
+        #
+        attr_reader :sandbox
+
+        # @return [String] path
+        #         Path of the project.
+        #
+        attr_reader :path
+
+        # @return [Array<PodTarget>] pod_targets
+        #         Array of pod targets this project includes.
+        #
+        attr_reader :pod_targets
+
+        # @return [Hash{String=>Symbol}] A hash representing all the user build
+        #         configurations across all integration targets. Each key
+        #         corresponds to the name of a configuration and its value to
+        #         its type (`:debug` or `:release`).
+        #
+        attr_reader :build_configurations
+
+        # @return [Array<Platform>] The list of all platforms this project supports.
+        #
+        attr_reader :platforms
+
+        # @return [Integer] Object version for the Xcode project.
+        #
+        attr_reader :object_version
+
+        # @return [String] Path to the Podfile included in the project.
+        #
+        attr_reader :podfile_path
+
+        # @return [Bool] Bool indicating if this project is a pod target subproject.
+        # Used by `generate_multiple_pod_projects` installation option.
+        #
+        attr_reader :pod_target_subproject
+
+        # Initialize a new instance
+        #
+        # @param [Sandbox] sandbox @see #sandbox
+        # @param [String] path @see #path
+        # @param [Array<PodTarget>] pod_targets @see #pod_targets
+        # @param [Hash{String=>Symbol}] build_configurations @see #build_configurations
+        # @param [Array<Platform>] platforms @see #platforms
+        # @param [Integer] object_version @see #object_version
+        # @param [String] podfile_path @see #podfile_path
+        #
+        def initialize(sandbox, path, pod_targets, build_configurations, platforms,
+                       object_version, podfile_path = nil, pod_target_subproject: false)
+          @sandbox = sandbox
+          @path = path
+          @pod_targets = pod_targets
+          @build_configurations = build_configurations
+          @platforms = platforms
+          @object_version = object_version
+          @podfile_path = podfile_path
+          @pod_target_subproject = pod_target_subproject
+        end
+
+        public
+
+        # @return [Project] Generated and prepared project.
+        #
+        def generate!
+          project = create_project(path, object_version, pod_target_subproject)
+          prepare(sandbox, project, pod_targets, build_configurations, platforms, podfile_path)
+          project
+        end
+
+        private
+
+        def create_project(path, object_version, pod_target_subproject)
+          object_version ||= Xcodeproj::Constants::DEFAULT_OBJECT_VERSION
+          Pod::Project.new(path, false, object_version, :pod_target_subproject => pod_target_subproject)
+        end
+
+        def prepare(sandbox, project, pod_targets, build_configurations, platforms, podfile_path)
+          UI.message "- Creating #{project.project_name} project" do
+            build_configurations.each do |name, type|
+              project.add_build_configuration(name, type)
+            end
+            # Reset symroot just in case the user has added a new build configuration other than 'Debug' or 'Release'.
+            project.symroot = Pod::Project::LEGACY_BUILD_ROOT
+            pod_names = pod_targets.map(&:pod_name).uniq
+            pod_names.each do |pod_name|
+              local = sandbox.local?(pod_name)
+              path = sandbox.pod_dir(pod_name)
+              was_absolute = sandbox.local_path_was_absolute?(pod_name)
+              project.add_pod_group(pod_name, path, local, was_absolute)
+            end
+            if podfile_path
+              project.add_podfile(podfile_path)
+            end
+            osx_deployment_target = platforms.select { |p| p.name == :osx }.map(&:deployment_target).min
+            ios_deployment_target = platforms.select { |p| p.name == :ios }.map(&:deployment_target).min
+            watchos_deployment_target = platforms.select { |p| p.name == :watchos }.map(&:deployment_target).min
+            tvos_deployment_target = platforms.select { |p| p.name == :tvos }.map(&:deployment_target).min
+            project.build_configurations.each do |build_configuration|
+              build_configuration.build_settings['MACOSX_DEPLOYMENT_TARGET'] = osx_deployment_target.to_s if osx_deployment_target
+              build_configuration.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = ios_deployment_target.to_s if ios_deployment_target
+              build_configuration.build_settings['WATCHOS_DEPLOYMENT_TARGET'] = watchos_deployment_target.to_s if watchos_deployment_target
+              build_configuration.build_settings['TVOS_DEPLOYMENT_TARGET'] = tvos_deployment_target.to_s if tvos_deployment_target
+              build_configuration.build_settings['STRIP_INSTALLED_PRODUCT'] = 'NO'
+              build_configuration.build_settings['CLANG_ENABLE_OBJC_ARC'] = 'YES'
+              build_configuration.build_settings['CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED'] = 'YES'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/installer/xcode/pods_project_generator/target_installation_result.rb

@@ -0,0 +1,140 @@
+module Pod
+  class Installer
+    class Xcode
+      class PodsProjectGenerator
+        # A simple container produced after a target installation is completed.
+        #
+        class TargetInstallationResult
+          # @return [Target] target
+          #         The target this installation result is for.
+          #
+          attr_reader :target
+
+          # @return [PBXNativeTarget] native_target
+          #         The native target that was produced for this target.
+          #
+          attr_reader :native_target
+
+          # @return [Array<PBXNativeTarget>] resource_bundle_targets
+          #         The resource bundle targets that were produced for this target. Can be empty if the target had
+          #         no resource bundles.
+          #
+          attr_reader :resource_bundle_targets
+
+          # @return [Array<PBXNativeTarget>] test_native_targets
+          #         The test native targets that were produced for this target. Can be empty if there were no test
+          #         native targets created (e.g. no test specs present).
+          #
+          attr_reader :test_native_targets
+
+          # @return [Hash{String=>Array<PBXNativeTarget>}] test_resource_bundle_targets
+          #         The test resource bundle targets that were produced for this target keyed by test spec name.
+          #         Can be empty if the target had no resource bundles for any tests.
+          #
+          attr_reader :test_resource_bundle_targets
+
+          # @return [Array<PBXNativeTarget>] test_app_host_targets
+          #         The test app host native targets that were produced for this target. Can be empty.
+          #
+          attr_reader :test_app_host_targets
+
+          # @return [Hash{Specification => PBXNativeTarget}] app_native_targets
+          #         The app native targets that were produced for this target. Can be empty if there were no app
+          #         native targets created (e.g. no app specs present).
+          #
+          attr_reader :app_native_targets
+
+          # @return [Hash{String=>Array<PBXNativeTarget>}] app_resource_bundle_targets
+          #         The app resource bundle targets that were produced for this target keyed by app spec name.
+          #         Can be empty if the target had no resource bundles for any apps.
+          #
+          attr_reader :app_resource_bundle_targets
+
+          # Initialize a new instance
+          #
+          # @param [Target] target @see #target
+          # @param [PBXNativeTarget] native_target @see #native_target
+          # @param [Array<PBXNativeTarget>] resource_bundle_targets @see #resource_bundle_targets
+          # @param [Array<PBXNativeTarget>] test_native_targets @see #test_native_targets
+          # @param [Hash{String=>Array<PBXNativeTarget>}] test_resource_bundle_targets @see #test_resource_bundle_targets
+          # @param [Array<PBXNativeTarget>] test_app_host_targets @see #test_app_host_targets
+          # @param [Hash{Specification => PBXNativeTarget}] app_native_targets @see #app_native_targets
+          # @param [Hash{String=>Array<PBXNativeTarget>}] app_resource_bundle_targets @see #app_resource_bundle_targets
+          #
+          def initialize(target, native_target, resource_bundle_targets = [], test_native_targets = [],
+                         test_resource_bundle_targets = {}, test_app_host_targets = [],
+                         app_native_targets = {}, app_resource_bundle_targets = {})
+            @target = target
+            @native_target = native_target
+            @resource_bundle_targets = resource_bundle_targets
+            @test_native_targets = test_native_targets
+            @test_resource_bundle_targets = test_resource_bundle_targets
+            @test_app_host_targets = test_app_host_targets
+            @app_native_targets = app_native_targets
+            @app_resource_bundle_targets = app_resource_bundle_targets
+          end
+
+          # Returns the corresponding native target to use based on the provided specification.
+          #
+          # @param  [Specification] spec
+          #         The specification to base from in order to find the native target.
+          #
+          # @return [PBXNativeTarget, Nil] the native target to use or `nil` if none is found.
+          #
+          def native_target_for_spec(spec)
+            return native_target if spec.library_specification?
+            return test_native_target_from_spec(spec) if spec.test_specification?
+            app_native_target_from_spec(spec) if spec.app_specification?
+          end
+
+          # @return [Hash{PBXNativeTarget => Specification}] a hash where the keys are the test native targets and the value
+          #         is the test spec associated with this native target.
+          #
+          def test_specs_by_native_target
+            test_specs_by_native_target = Hash[target.test_specs.map { |spec| [test_native_target_from_spec(spec), spec] }]
+            test_specs_by_native_target.delete_if { |k, _| k.nil? }
+          end
+
+          # @return [Hash{PBXNativeTarget => Specification}] a hash where the keys are the app native targets and the value
+          #         is the app spec associated with this native target.
+          #
+          def app_specs_by_native_target
+            app_specs_by_native_target = Hash[target.app_specs.map { |spec| [app_native_target_from_spec(spec), spec] }]
+            app_specs_by_native_target.delete_if { |k, _| k.nil? }
+          end
+
+          # @return [Hash{PBXNativeTarget => Specification}] a hash where the keys are the native targets and the value
+          #         is the non-library spec associated with this native target.
+          #
+          def non_library_specs_by_native_target
+            test_specs_by_native_target.merge(app_specs_by_native_target)
+          end
+
+          # @param label [String] the label of the app host target.
+          #
+          # @return [PBXNativeTarget] the app host target with the given target label.
+          #
+          def app_host_target_labelled(label)
+            app_native_targets.values.find do |app_native_target|
+              app_native_target.name == label
+            end || test_app_host_targets.find do |app_native_target|
+              app_native_target.name == label
+            end
+          end
+
+          private
+
+          def test_native_target_from_spec(spec)
+            test_native_targets.find do |test_native_target|
+              test_native_target.name == target.test_target_label(spec)
+            end
+          end
+
+          def app_native_target_from_spec(spec)
+            app_native_targets[spec]
+          end
+        end
+      end
+    end
+  end
+end