cocoapods-tt 0.0.1

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

@@ -0,0 +1,154 @@
+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 project 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 of the sub group.
+          #
+          attr_reader :subgroup_name
+
+          # @return [String] the name of the group the app host installer will be installing within.
+          #
+          attr_reader :group_name
+
+          # @return [String] the name of the app target label that will be used.
+          #
+          attr_reader :app_target_label
+
+          # @return [Boolean] whether the app host installer should add main.m
+          #
+          attr_reader :add_main
+
+          # @return [Boolean] whether the app host installer should add a launch screen storyboard
+          #
+          attr_reader :add_launchscreen_storyboard
+
+          # @return [Hash] Info.plist entries for the app host
+          #
+          attr_reader :info_plist_entries
+
+          # @return [String] product_basename
+          #         The product basename to use for the target.
+          #
+          attr_reader :product_basename
+
+          # Initialize a new instance
+          #
+          # @param [Sandbox] sandbox @see #sandbox
+          # @param [Pod::Project] project @see #project
+          # @param [Platform] platform @see #platform
+          # @param [String] subgroup_name @see #subgroup_name
+          # @param [String] group_name @see #group_name
+          # @param [String] app_target_label see #app_target_label
+          # @param [Boolean] add_main see #add_main
+          # @param [Hash] info_plist_entries see #info_plist_entries
+          # @param [String] product_basename see #product_basename
+          #
+          def initialize(sandbox, project, platform, subgroup_name, group_name, app_target_label, add_main: true,
+                         add_launchscreen_storyboard: platform == :ios, info_plist_entries: {}, product_basename: nil)
+            @sandbox = sandbox
+            @project = project
+            @platform = platform
+            @subgroup_name = subgroup_name
+            @group_name = group_name
+            @app_target_label = app_target_label
+            @add_main = add_main
+            @add_launchscreen_storyboard = add_launchscreen_storyboard
+            @info_plist_entries = info_plist_entries
+            @product_basename = product_basename || app_target_label
+            target_group = project.pod_group(group_name)
+            @group = target_group[subgroup_name] || target_group.new_group(subgroup_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,
+                                                                             app_target_label, product_basename)
+            app_host_target.build_configurations.each do |configuration|
+              configuration.build_settings['PRODUCT_NAME'] = product_basename
+              configuration.build_settings['PRODUCT_BUNDLE_IDENTIFIER'] = 'org.cocoapods.${PRODUCT_NAME:rfc1034identifier}'
+              if platform == :osx
+                configuration.build_settings['CODE_SIGN_IDENTITY'] = ''
+              elsif platform == :ios
+                configuration.build_settings['CODE_SIGN_IDENTITY'] = 'iPhone Developer'
+              end
+              configuration.build_settings['CURRENT_PROJECT_VERSION'] = '1'
+            end
+
+            Pod::Generator::AppTargetHelper.add_app_host_main_file(project, app_host_target, platform_name, @group, app_target_label) if add_main
+            Pod::Generator::AppTargetHelper.add_launchscreen_storyboard(project, app_host_target, @group, deployment_target, app_target_label) if add_launchscreen_storyboard
+            create_info_plist_file_with_sandbox(sandbox, app_host_info_plist_path, app_host_target, '1.0.0', platform,
+                                                :appl, :additional_entries => additional_info_plist_entries)
+            @group.new_file(app_host_info_plist_path)
+            app_host_target
+          end
+
+          private
+
+          ADDITIONAL_INFO_PLIST_ENTRIES = {
+            'NSAppTransportSecurity' => {
+              'NSAllowsArbitraryLoads' => true,
+            },
+          }.freeze
+
+          ADDITIONAL_IOS_INFO_PLIST_ENTRIES = {
+            'UILaunchStoryboardName' => 'LaunchScreen',
+            'UISupportedInterfaceOrientations' => %w(
+              UIInterfaceOrientationPortrait
+              UIInterfaceOrientationLandscapeLeft
+              UIInterfaceOrientationLandscapeRight
+            ),
+            'UISupportedInterfaceOrientations~ipad' => %w(
+              UIInterfaceOrientationPortrait
+              UIInterfaceOrientationPortraitUpsideDown
+              UIInterfaceOrientationLandscapeLeft
+              UIInterfaceOrientationLandscapeRight
+            ),
+          }.freeze
+
+          # @return [Hash] the additional Info.plist entries to be included
+          #
+          def additional_info_plist_entries
+            result = {}
+            result.merge!(ADDITIONAL_INFO_PLIST_ENTRIES)
+            result.merge!(ADDITIONAL_IOS_INFO_PLIST_ENTRIES) if platform == :ios
+            result.merge!(info_plist_entries) if info_plist_entries
+            result
+          end
+
+          # @return [Pathname] The absolute path of the Info.plist to use for an app host.
+          #
+          def app_host_info_plist_path
+            project.path.dirname.+(subgroup_name).+("#{app_target_label}-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-tt/native/installer/xcode/pods_project_generator/file_references_installer.rb

@@ -0,0 +1,329 @@
+module Pod
+  class Installer
+    class Xcode
+      class PodsProjectGenerator
+        # Controller class responsible of installing the file references of the
+        # specifications in the Pods project.
+        #
+        class FileReferencesInstaller
+          # Regex for extracting the region portion of a localized file path. Ex. `Resources/en.lproj` --> `en`
+          LOCALIZATION_REGION_FILEPATTERN_REGEX = /(\/|^)(?<region>[^\/]*?)\.lproj(\/|$)/
+
+          # @return [Sandbox] The sandbox of the installation.
+          #
+          attr_reader :sandbox
+
+          # @return [Array<PodTarget>] The pod targets of the installation.
+          #
+          attr_reader :pod_targets
+
+          # @return [Project] The project to install the file references into.
+          #
+          attr_reader :pods_project
+
+          # @return [Bool] add support for preserving the file structure of externally sourced pods, in addition to local pods.
+          #
+          attr_reader :preserve_pod_file_structure
+
+          # Initialize a new instance
+          #
+          # @param [Sandbox] sandbox @see #sandbox
+          # @param [Array<PodTarget>] pod_targets @see #pod_targets
+          # @param [Project] pods_project @see #pods_project
+          # @param [Bool] preserve_pod_file_structure @see #preserve_pod_file_structure
+          #
+          def initialize(sandbox, pod_targets, pods_project, preserve_pod_file_structure = false)
+            @sandbox = sandbox
+            @pod_targets = pod_targets
+            @pods_project = pods_project
+            @preserve_pod_file_structure = preserve_pod_file_structure
+          end
+
+          # Installs the file references.
+          #
+          # @return [void]
+          #
+          def install!
+            refresh_file_accessors
+            prepare_pod_groups
+            add_source_files_references
+            add_frameworks_bundles
+            add_vendored_libraries
+            add_resources
+            add_developer_files unless sandbox.development_pods.empty?
+            link_headers
+          end
+
+          #-----------------------------------------------------------------------#
+
+          private
+
+          # @!group Installation Steps
+
+          # Reads the file accessors contents from the file system.
+          #
+          # @note   The contents of the file accessors are modified by the clean
+          #         step of the #{PodSourceInstaller} and by the pre install hooks.
+          #
+          # @return [void]
+          #
+          def refresh_file_accessors
+            file_accessors.reject do |file_accessor|
+              pod_name = file_accessor.spec.name
+              sandbox.local?(pod_name)
+            end.map(&:path_list).uniq.each(&:read_file_system)
+          end
+
+          # Prepares the main groups to which all files will be added for the respective target
+          #
+          def prepare_pod_groups
+            file_accessors.each do |file_accessor|
+              pod_name = file_accessor.spec.name
+              next unless sandbox.local?(pod_name)
+              root_name = Specification.root_name(pod_name)
+              path = file_accessor.root
+              group = pods_project.group_for_spec(root_name)
+              group.set_path(path) unless group.path == path
+            end
+          end
+
+          # Adds the source files of the Pods to the Pods project.
+          #
+          # @note   The source files are grouped by Pod and in turn by subspec
+          #         (recursively).
+          #
+          # @return [void]
+          #
+          def add_source_files_references
+            UI.message '- Adding source files' do
+              add_file_accessors_paths_to_pods_group(:source_files, nil, true)
+            end
+          end
+
+          # Adds the bundled frameworks to the Pods project
+          #
+          # @return [void]
+          #
+          def add_frameworks_bundles
+            UI.message '- Adding frameworks' do
+              add_file_accessors_paths_to_pods_group(:vendored_frameworks, :frameworks)
+            end
+          end
+
+          # Adds the bundled libraries to the Pods project
+          #
+          # @return [void]
+          #
+          def add_vendored_libraries
+            UI.message '- Adding libraries' do
+              add_file_accessors_paths_to_pods_group(:vendored_libraries, :frameworks)
+            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
+          #         (recursively) in the resources group.
+          #
+          # @return [void]
+          #
+          def add_resources
+            UI.message '- Adding resources' do
+              refs = add_file_accessors_paths_to_pods_group(:resources, :resources, true)
+              refs.concat add_file_accessors_paths_to_pods_group(:resource_bundle_files, :resources, true)
+              add_known_regions(refs)
+            end
+          end
+
+          def add_developer_files
+            UI.message '- Adding development pod helper files' do
+              file_accessors.each do |file_accessor|
+                pod_name = file_accessor.spec.name
+                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|
+                  ref = pods_project.add_file_reference(path, group, false)
+                  if path.extname == '.podspec'
+                    pods_project.mark_ruby_file_ref(ref)
+                  end
+                end
+              end
+            end
+          end
+
+          # Creates the link to the headers of the Pod in the sandbox.
+          #
+          # @return [void]
+          #
+          def link_headers
+            UI.message '- Linking headers' do
+              pod_targets.each do |pod_target|
+                # When integrating Pod as frameworks, built Pods are built into
+                # frameworks, whose headers are included inside the built
+                # framework. Those headers do not need to be linked from the
+                # sandbox.
+                next if pod_target.build_as_framework? && pod_target.should_build?
+
+                pod_target_header_mappings = pod_target.header_mappings_by_file_accessor.values
+                pod_target_header_mappings.each do |header_mappings|
+                  header_mappings.each do |namespaced_path, files|
+                    pod_target.build_headers.add_files(namespaced_path, files)
+                  end
+                end
+
+                public_header_mappings = pod_target.public_header_mappings_by_file_accessor.values
+                public_header_mappings.each do |header_mappings|
+                  header_mappings.each do |namespaced_path, files|
+                    sandbox.public_headers.add_files(namespaced_path, files)
+                  end
+                end
+              end
+            end
+          end
+
+          #-----------------------------------------------------------------------#
+
+          private
+
+          # @!group Private Helpers
+
+          # @return [Array<Sandbox::FileAccessor>] The file accessors for all the
+          #         specs platform combinations.
+          #
+          def file_accessors
+            @file_accessors ||= pod_targets.flat_map(&:file_accessors).compact
+          end
+
+          # Adds file references to the list of the paths returned by the file
+          # accessor with the given key to the given group of the Pods project.
+          #
+          # @param  [Symbol] file_accessor_key
+          #         The method of the file accessor which would return the list of
+          #         the paths.
+          #
+          # @param  [Symbol] group_key
+          #         The key of the group of the Pods project.
+          #
+          # @param  [Bool] reflect_file_system_structure
+          #         Whether organizing a local pod's files in subgroups inside
+          #         the pod's group is allowed.
+          #
+          # @return [Array<PBXFileReference>] the added file references
+          #
+          def add_file_accessors_paths_to_pods_group(file_accessor_key, group_key = nil, reflect_file_system_structure = false)
+            file_accessors.flat_map do |file_accessor|
+              paths = file_accessor.send(file_accessor_key)
+              paths = allowable_project_paths(paths)
+              next [] if paths.empty?
+
+              pod_name = file_accessor.spec.name
+              preserve_pod_file_structure_flag = (sandbox.local?(pod_name) || preserve_pod_file_structure) && reflect_file_system_structure
+              base_path = preserve_pod_file_structure_flag ? common_path(paths) : nil
+              actual_group_key = preserve_pod_file_structure_flag ? nil : group_key
+              group = pods_project.group_for_spec(pod_name, actual_group_key)
+              paths.map do |path|
+                pods_project.add_file_reference(path, group, preserve_pod_file_structure_flag, base_path)
+              end
+            end
+          end
+
+          # Filters a list of paths down to those paths which can be added to
+          # the Xcode project. Some paths are intermediates and only their children
+          # should be added, while some paths are treated as bundles and their
+          # children should not be added directly.
+          #
+          # @param  [Array<Pathname>] paths
+          #         The paths to files or directories on disk.
+          #
+          # @return [Array<Pathname>] The paths which can be added to the Xcode project
+          #
+          def allowable_project_paths(paths)
+            lproj_paths = Set.new
+            lproj_paths_with_files = Set.new
+            allowable_paths = paths.select do |path|
+              path_str = path.to_s
+
+              # We add the directory for a Core Data model, but not the items in it.
+              next if path_str =~ /.*\.xcdatamodeld\/.+/i
+
+              # We add the directory for a Core Data migration mapping, but not the items in it.
+              next if path_str =~ /.*\.xcmappingmodel\/.+/i
+
+              # We add the directory for an asset catalog, but not the items in it.
+              next if path_str =~ /.*\.xcassets\/.+/i
+
+              if path_str =~ /\.lproj(\/|$)/i
+                # If the element is an .lproj directory then save it and potentially
+                # add it later if we don't find any contained items.
+                if path_str =~ /\.lproj$/i && path.directory?
+                  lproj_paths << path
+                  next
+                end
+
+                # Collect the paths for the .lproj directories that contain files.
+                lproj_path = /(^.*\.lproj)\/.*/i.match(path_str)[1]
+                lproj_paths_with_files << Pathname(lproj_path)
+
+                # Directories nested within an .lproj directory are added as file
+                # system references so their contained items are not added directly.
+                next if path.dirname.dirname == lproj_path
+              end
+
+              true
+            end
+
+            # Only add the path for the .lproj directories that do not have anything
+            # within them added as well. This generally happens if the glob within the
+            # resources directory was not a recursive glob.
+            allowable_paths + lproj_paths.subtract(lproj_paths_with_files).to_a
+          end
+
+          # Returns a Pathname of the nearest parent from which all the given paths descend.
+          # Converts each Pathname to a list of path components and finds the longest common prefix
+          #
+          # @param  [Array<Pathname>] paths
+          #         The paths to files or directories on disk. Must be absolute paths
+          #
+          # @return [Pathname] Pathname of the nearest parent shared by paths, or nil if none exists
+          #
+          def common_path(paths)
+            return nil if paths.empty?
+            strs = paths.map do |path|
+              unless path.absolute?
+                raise ArgumentError, "Paths must be absolute #{path}"
+              end
+              path.dirname.to_s
+            end
+            min, max = strs.minmax
+            min = min.split('/')
+            max = max.split('/')
+            idx = min.size.times { |i| break i if min[i] != max[i] }
+            result = Pathname.new(min[0...idx].join('/'))
+            # Don't consider "/" a common path
+            return result unless result.to_s == '' || result.to_s == '/'
+          end
+
+          # Adds the known localization regions to the root of the project
+          #
+          # @param [Array<PBXFileReferences>] file_references the resource file references
+          #
+          def add_known_regions(file_references)
+            pattern = LOCALIZATION_REGION_FILEPATTERN_REGEX
+            regions = file_references.map do |ref|
+              if (match = ref.path.to_s.match(pattern))
+                match[:region]
+              end
+            end.compact
+
+            pods_project.root_object.known_regions = (pods_project.root_object.known_regions | regions).sort
+          end
+
+          #-----------------------------------------------------------------------#
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,195 @@
+module Pod
+  class Installer
+    class Xcode
+      # Wires up the dependencies between targets from the target installation results
+      #
+      class PodTargetDependencyInstaller
+        require 'cocoapods/native_target_extension.rb'
+
+        # @return [Sandbox] The sandbox used for this installation.
+        #
+        attr_reader :sandbox
+
+        # @return [TargetInstallationResults] The target installation results for pod targets.
+        #
+        attr_reader :pod_target_installation_results
+
+        # @return [ProjectMetadataCache] The metadata cache for targets.
+        #
+        attr_reader :metadata_cache
+
+        # Initialize a new instance.
+        #
+        # @param [Sandbox] sandbox @see #sandbox
+        # @param [TargetInstallationResults] pod_target_installation_results @see #pod_target_installation_results
+        # @param [ProjectMetadataCache] metadata_cache @see #metadata_cache
+        #
+        def initialize(sandbox, pod_target_installation_results, metadata_cache)
+          @sandbox = sandbox
+          @pod_target_installation_results = pod_target_installation_results
+          @metadata_cache = metadata_cache
+        end
+
+        def install!
+          # Wire up pod targets
+          pod_target_installation_results.values.each do |pod_target_installation_result|
+            pod_target = pod_target_installation_result.target
+            native_target = pod_target_installation_result.native_target
+            project = native_target.project
+
+            # First, wire up all resource bundles.
+            wire_resource_bundle_targets(pod_target_installation_result.resource_bundle_targets,
+                                         native_target, pod_target)
+            # Wire up all dependencies to this pod target, if any.
+            wire_target_dependencies(pod_target, native_target, project, pod_target_installation_results,
+                                     metadata_cache)
+
+            # Wire up test native targets.
+            unless pod_target_installation_result.test_native_targets.empty?
+              wire_test_native_targets(pod_target, pod_target_installation_result, pod_target_installation_results,
+                                       project, metadata_cache)
+            end
+
+            # Wire up app native targets.
+            unless pod_target_installation_result.app_native_targets.empty?
+              wire_app_native_targets(pod_target, pod_target_installation_result, pod_target_installation_results,
+                                      project, metadata_cache)
+            end
+          end
+        end
+
+        private
+
+        def wire_resource_bundle_targets(resource_bundle_targets, native_target, pod_target)
+          resource_bundle_targets.each do |resource_bundle_target|
+            native_target.add_dependency(resource_bundle_target)
+            if pod_target.build_as_dynamic_framework? && pod_target.should_build?
+              native_target.add_resources([resource_bundle_target.product_reference])
+            end
+          end
+        end
+
+        def wire_target_dependencies(pod_target, native_target, project, pod_target_installation_results, metadata_cache)
+          dependent_targets = pod_target.dependent_targets
+          dependent_targets.each do |dependent_target|
+            is_local = sandbox.local?(dependent_target.pod_name)
+            if installation_result = pod_target_installation_results[dependent_target.name]
+              dependent_project = installation_result.native_target.project
+              if dependent_project != project
+                project.add_pod_subproject(dependent_project, is_local)
+              end
+              native_target.add_dependency(installation_result.native_target)
+            else
+              # Hit the cache
+              cached_dependency = metadata_cache.target_label_by_metadata[dependent_target.label]
+              project.add_cached_pod_subproject(sandbox, cached_dependency, is_local)
+              Project.add_cached_dependency(sandbox, native_target, cached_dependency)
+            end
+          end
+        end
+
+        def wire_test_native_targets(pod_target, installation_result, pod_target_installation_results, project, metadata_cache)
+          installation_result.test_specs_by_native_target.each do |test_native_target, test_spec|
+            resource_bundle_native_targets = installation_result.test_resource_bundle_targets[test_spec.name] || []
+            resource_bundle_native_targets.each do |test_resource_bundle_target|
+              test_native_target.add_dependency(test_resource_bundle_target)
+            end
+
+            test_dependent_targets = pod_target.test_dependent_targets_by_spec_name.fetch(test_spec.name, []).+([pod_target]).uniq
+            test_dependent_targets.each do |test_dependent_target|
+              is_local = sandbox.local?(test_dependent_target.pod_name)
+              if dependency_installation_result = pod_target_installation_results[test_dependent_target.name]
+                dependent_test_project = dependency_installation_result.native_target.project
+                if dependent_test_project != project
+                  project.add_pod_subproject(dependent_test_project, is_local)
+                end
+                test_native_target.add_dependency(dependency_installation_result.native_target)
+              else
+                # Hit the cache
+                cached_dependency = metadata_cache.target_label_by_metadata[test_dependent_target.label]
+                project.add_cached_pod_subproject(sandbox, cached_dependency, is_local)
+                Project.add_cached_dependency(sandbox, test_native_target, cached_dependency)
+              end
+            end
+
+            if app_host_target_label = pod_target.app_host_target_label(test_spec)
+              app_host_pod_target_label, app_host_target_label = *app_host_target_label
+              wire_test_native_target_app_host(test_native_target, pod_target, pod_target_installation_results, project, metadata_cache, app_host_pod_target_label, app_host_target_label)
+            end
+          end
+        end
+
+        def wire_test_native_target_app_host(test_native_target, pod_target, pod_target_installation_results, project, metadata_cache, app_host_pod_target_label, app_host_target_label)
+          if dependency_installation_result = pod_target_installation_results[app_host_pod_target_label]
+            unless app_native_target = dependency_installation_result.app_host_target_labelled(app_host_target_label)
+              raise Informative, "Did not find target with label #{app_host_target_label} in the set of targets installed for #{app_host_pod_target_label}."
+            end
+
+            dependent_test_project = app_native_target.project
+            if dependent_test_project != project
+              project.add_subproject_reference(dependent_test_project, project.dependencies_group)
+            end
+
+            app_host_target_names = app_native_target.resolved_build_setting('PRODUCT_NAME', true)
+            test_native_target.build_configurations.each do |configuration|
+              app_host_target_name = app_host_target_names[configuration.name] || target.name
+              case test_native_target.symbol_type
+              when :unit_test_bundle
+                test_host = "$(BUILT_PRODUCTS_DIR)/#{app_host_target_name}.app/"
+                test_host << 'Contents/MacOS/' if pod_target.platform == :osx
+                test_host << app_host_target_name.to_s
+                configuration.build_settings['BUNDLE_LOADER'] = '$(TEST_HOST)'
+                configuration.build_settings['TEST_HOST'] = test_host
+              when :ui_test_bundle
+                configuration.build_settings['TEST_TARGET_NAME'] = app_host_target_name
+              end
+            end
+            target_attributes = project.root_object.attributes['TargetAttributes'] || {}
+            target_attributes[test_native_target.uuid.to_s] = { 'TestTargetID' => app_native_target.uuid.to_s }
+            project.root_object.attributes['TargetAttributes'] = target_attributes
+            test_native_target.add_dependency(app_native_target)
+          elsif cached_dependency = metadata_cache.target_label_by_metadata[app_host_target_label]
+            # Hit the cache
+            project.add_cached_subproject_reference(sandbox, cached_dependency, project.dependencies_group)
+            Project.add_cached_dependency(sandbox, test_native_target, cached_dependency)
+          else
+            raise "Expected to either have an installation or cache result for #{app_host_target_label} (from pod #{app_host_pod_target_label}) " \
+              "for target #{test_native_target.name} in project #{project.project_name}"
+          end
+        end
+
+        def wire_app_native_targets(pod_target, installation_result, pod_target_installation_results, project, metadata_cache)
+          installation_result.app_specs_by_native_target.each do |app_native_target, app_spec|
+            resource_bundle_native_targets = installation_result.app_resource_bundle_targets[app_spec.name] || []
+            resource_bundle_native_targets.each do |app_resource_bundle_target|
+              app_native_target.add_dependency(app_resource_bundle_target)
+            end
+
+            app_dependent_targets = pod_target.app_dependent_targets_by_spec_name.fetch(app_spec.name, []).unshift(pod_target).uniq
+            app_dependent_targets.each do |app_dependent_target|
+              is_local = sandbox.local?(app_dependent_target.pod_name)
+              if dependency_installation_result = pod_target_installation_results[app_dependent_target.name]
+                resource_bundle_native_targets = dependency_installation_result.app_resource_bundle_targets[app_spec.name]
+                unless resource_bundle_native_targets.nil?
+                  resource_bundle_native_targets.each do |app_resource_bundle_target|
+                    app_native_target.add_dependency(app_resource_bundle_target)
+                  end
+                end
+                dependency_project = dependency_installation_result.native_target.project
+                if dependency_project != project
+                  project.add_pod_subproject(dependency_project, is_local)
+                end
+                app_native_target.add_dependency(dependency_installation_result.native_target)
+              else
+                # Hit the cache
+                cached_dependency = metadata_cache.target_label_by_metadata[app_dependent_target.label]
+                project.add_cached_pod_subproject(sandbox, cached_dependency, is_local)
+                Project.add_cached_dependency(sandbox, app_native_target, cached_dependency)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end