cocoapods 1.6.2 → 1.7.0.beta.1

data/lib/cocoapods/installer/project_cache/target_cache_key.rb

@@ -0,0 +1,134 @@
+module Pod
+  class Installer
+    module ProjectCache
+      # Uniquely identifies a Target.
+      #
+      class TargetCacheKey
+        require 'cocoapods/target/pod_target.rb'
+        require 'cocoapods/target/aggregate_target.rb'
+        require 'digest'
+
+        # @return [Symbol]
+        #         The type of target. Either aggregate or pod target.
+        #
+        attr_reader :type
+
+        # @return [Hash{String => Object}]
+        #         The hash containing key-value pairs that identify the target.
+        #
+        attr_reader :key_hash
+
+        # Initialize a new instance.
+        #
+        # @param [Symbol] type @see #type
+        # @param [Hash{String => Object}] key_hash @see #key_hash
+        #
+        def initialize(type, key_hash)
+          @type = type
+          @key_hash = key_hash
+        end
+
+        # Equality function used to compare TargetCacheKey objects to each other.
+        #
+        # @param [TargetCacheKey] other
+        #        Other object to compare itself against.
+        #
+        # @return [Symbol] The difference between this and another TargetCacheKey object.
+        #         # Symbol :none means no difference.
+        #
+        def key_difference(other)
+          if other.type != type
+            :project
+          else
+            case type
+            when :pod_target
+              return :project if (other.key_hash.keys - key_hash.keys).any?
+              return :project if other.key_hash['CHECKSUM'] != key_hash['CHECKSUM']
+              return :project if other.key_hash['SPECS'] != key_hash['SPECS']
+              return :project if other.key_hash['FILES'] != key_hash['FILES']
+            end
+
+            this_build_settings = key_hash['BUILD_SETTINGS_CHECKSUM']
+            other_build_settings = other.key_hash['BUILD_SETTINGS_CHECKSUM']
+            return :project if this_build_settings != other_build_settings
+
+            this_checkout_options = key_hash['CHECKOUT_OPTIONS']
+            other_checkout_options = other.key_hash['CHECKOUT_OPTIONS']
+            return :project if this_checkout_options != other_checkout_options
+
+            :none
+          end
+        end
+
+        def to_h
+          key_hash
+        end
+
+        # Creates a TargetCacheKey instance from the given hash.
+        #
+        # @param [Hash{String => Object}] key_hash
+        #        The hash used to construct a TargetCacheKey object.
+        #
+        # @return [TargetCacheKey]
+        #
+        def self.from_cache_hash(key_hash)
+          cache_hash = key_hash.dup
+          if files = cache_hash['FILES']
+            cache_hash['FILES'] = files.sort
+          end
+          type = cache_hash['CHECKSUM'] ? :pod_target : :aggregate
+          TargetCacheKey.new(type, cache_hash)
+        end
+
+        # Constructs a TargetCacheKey instance from a PodTarget.
+        #
+        # @param [PodTarget] pod_target
+        #        The pod target used to construct a TargetCacheKey object.
+        #
+        # @param [Bool] is_local_pod
+        #        Used to also include its local files in the cache key.
+        #
+        # @param [Hash] checkout_options
+        #        The checkout options for this pod target.
+        #
+        # @return [TargetCacheKey]
+        #
+        def self.from_pod_target(pod_target, is_local_pod: false, checkout_options: nil)
+          build_settings = {}
+          build_settings[pod_target.label.to_s] = Digest::MD5.hexdigest(pod_target.build_settings.xcconfig.to_s)
+          pod_target.test_spec_build_settings.each do |name, settings|
+            build_settings[name] = Digest::MD5.hexdigest(settings.xcconfig.to_s)
+          end
+          pod_target.app_spec_build_settings.each do |name, settings|
+            build_settings[name] = Digest::MD5.hexdigest(settings.xcconfig.to_s)
+          end
+
+          contents = {
+            'CHECKSUM' => pod_target.root_spec.checksum,
+            'SPECS' => pod_target.specs.map(&:to_s).sort,
+            'BUILD_SETTINGS_CHECKSUM' => build_settings,
+          }
+          contents['FILES'] = pod_target.all_files.sort if is_local_pod
+          contents['CHECKOUT_OPTIONS'] = checkout_options if checkout_options
+          TargetCacheKey.new(:pod_target, contents)
+        end
+
+        # Construct a TargetCacheKey instance from an AggregateTarget.
+        #
+        # @param [AggregateTarget] aggregate_target
+        #        The aggregate target used to construct a TargetCacheKey object.
+        #
+        # @return [TargetCacheKey]
+        #
+        def self.from_aggregate_target(aggregate_target)
+          build_settings = {}
+          aggregate_target.user_build_configurations.keys.each do |configuration|
+            build_settings[configuration] = Digest::MD5.hexdigest(aggregate_target.build_settings(configuration).xcconfig.to_s)
+          end
+
+          TargetCacheKey.new(:aggregate, 'BUILD_SETTINGS_CHECKSUM' => build_settings)
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/installer/project_cache/target_metadata.rb

@@ -0,0 +1,70 @@
+module Pod
+  class Installer
+    module ProjectCache
+      # Metadata used to reconstruct a PBXTargetDependency.
+      #
+      class TargetMetadata
+        # @return [String]
+        #         The label of the native target.
+        #
+        attr_reader :target_label
+
+        # @return [String]
+        #         The UUID of the native target installed.
+        #
+        attr_reader :native_target_uuid
+
+        # @return [String]
+        #         The path of the container project the native target was installed into.
+        #
+        attr_reader :container_project_path
+
+        # Initialize a new instance.
+        #
+        # @param [String] target_label @see #target_label
+        # @param [String] native_target_uuid @see #native_target_uuid
+        # @param [String] container_project_path @see #container_project_path
+        #
+        def initialize(target_label, native_target_uuid, container_project_path)
+          @target_label = target_label
+          @native_target_uuid = native_target_uuid
+          @container_project_path = container_project_path
+        end
+
+        def to_hash
+          {
+            'LABEL' => target_label,
+            'UUID' => native_target_uuid,
+            'PROJECT_PATH' => container_project_path,
+          }
+        end
+
+        def to_s
+          "#{target_label} : #{native_target_uuid} : #{container_project_path}"
+        end
+
+        # Constructs a TargetMetadata instance from a hash.
+        #
+        # @param [Hash] hash
+        #        The hash used to construct a new TargetMetadata instance.
+        #
+        # @return [TargetMetadata]
+        #
+        def self.from_hash(hash)
+          TargetMetadata.new(hash['LABEL'], hash['UUID'], hash['PROJECT_PATH'])
+        end
+
+        # Constructs a TargetMetadata instance from a native target.
+        #
+        # @param [PBXNativeTarget] native_target
+        #        The native target used to construct a TargetMetadata instance.
+        #
+        # @return [TargetMetadata]
+        #
+        def self.from_native_target(native_target)
+          TargetMetadata.new(native_target.name, native_target.uuid, native_target.project.path.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/installer/sandbox_dir_cleaner.rb

@@ -0,0 +1,89 @@
+module Pod
+  class Installer
+    # Cleans up the sandbox directory by removing stale target support files and headers.
+    #
+    class SandboxDirCleaner
+      # @return [Sandbox] The sandbox directory that will be cleaned.
+      #
+      attr_reader :sandbox
+
+      # @return [Array<PodTarget>]
+      #         The list of all pod targets that will be installed into the Sandbox.
+      #
+      attr_reader :pod_targets
+
+      # @return [Array<AggregateTarget>]
+      #         The list of all aggregate targets that will be installed into the Sandbox.
+      #
+      attr_reader :aggregate_targets
+
+      # Initialize a new instance
+      #
+      # @param [Sandbox] sandbox @see #sandbox
+      # @param [Array<PodTarget>] pod_targets @see #pod_targets
+      # @param [Array<AggregateTarget>] aggregate_targets @see #aggregate_targets
+      #
+      def initialize(sandbox, pod_targets, aggregate_targets)
+        @sandbox = sandbox
+        @pod_targets = pod_targets
+        @aggregate_targets = aggregate_targets
+      end
+
+      def clean!
+        UI.message('Cleaning up sandbox directory') do
+          # Clean up Target Support Files Directory
+          target_support_dirs_to_install = (pod_targets + aggregate_targets).map(&:support_files_dir)
+          target_support_dirs = sandbox_target_support_dirs
+
+          removed_target_support_dirs = target_support_dirs - target_support_dirs_to_install
+          removed_target_support_dirs.each { |dir| remove_dir(dir) }
+
+          # Clean up Sandbox Headers Directory
+          sandbox_private_headers_to_install = pod_targets.flat_map do |pod_target|
+            if pod_target.header_mappings_by_file_accessor.empty?
+              []
+            else
+              [pod_target.build_headers.root.join(pod_target.headers_sandbox)]
+            end
+          end
+          sandbox_public_headers_to_install = pod_targets.flat_map do |pod_target|
+            if pod_target.public_header_mappings_by_file_accessor.empty?
+              []
+            else
+              [sandbox.public_headers.root.join(pod_target.headers_sandbox)]
+            end
+          end
+
+          removed_sandbox_public_headers = sandbox_public_headers - sandbox_public_headers_to_install
+          removed_sandbox_public_headers.each { |path| remove_dir(path) }
+
+          removed_sandbox_private_headers = sandbox_private_headers(pod_targets) - sandbox_private_headers_to_install
+          removed_sandbox_private_headers.each { |path| remove_dir(path) }
+        end
+      end
+
+      private
+
+      def sandbox_target_support_dirs
+        child_directories_of(sandbox.target_support_files_root)
+      end
+
+      def sandbox_private_headers(pod_targets)
+        pod_targets.flat_map { |pod_target| child_directories_of(pod_target.build_headers.root) }.uniq
+      end
+
+      def sandbox_public_headers
+        child_directories_of(sandbox.public_headers.root)
+      end
+
+      def child_directories_of(dir)
+        return [] unless dir.exist?
+        dir.children.select(&:directory?)
+      end
+
+      def remove_dir(path)
+        FileUtils.rm_rf(path)
+      end
+    end
+  end
+end

data/lib/cocoapods/installer/sandbox_header_paths_installer.rb

@@ -0,0 +1,45 @@
+module Pod
+  class Installer
+    # Adds all the search paths into the sandbox HeaderStore and each pod target's HeaderStore.
+    #
+    class SandboxHeaderPathsInstaller
+      # @return [Sandbox] The sandbox to use for this analysis.
+      #
+      attr_reader :sandbox
+
+      # @return [Array<PodTarget>] The list of pod targets to analyze.
+      #
+      attr_reader :pod_targets
+
+      # Initialize a new instance
+      #
+      # @param  [Sandbox] sandbox @see #sandbox
+      # @param  [Array<PodTarget>] pod_targets @see #pod_targets
+      #
+      def initialize(sandbox, pod_targets)
+        @pod_targets = pod_targets
+        @sandbox = sandbox
+      end
+
+      def install!
+        # Link all pod target header search paths into the HeaderStore.
+        pod_targets.each do |pod_target|
+          next if pod_target.build_as_framework? && pod_target.should_build?
+          install_target(pod_target)
+        end
+      end
+
+      private
+
+      def install_target(pod_target)
+        pod_target_header_mappings = pod_target.header_mappings_by_file_accessor.values
+        public_header_mappings = pod_target.public_header_mappings_by_file_accessor.values
+        added_build_headers = !pod_target_header_mappings.all?(&:empty?)
+        added_public_headers = !public_header_mappings.all?(&:empty?)
+
+        pod_target.build_headers.add_search_path(pod_target.headers_sandbox, pod_target.platform) if added_build_headers
+        sandbox.public_headers.add_search_path(pod_target.headers_sandbox, pod_target.platform) if added_public_headers
+      end
+    end
+  end
+end

data/lib/cocoapods/installer/target_uuid_generator.rb

@@ -0,0 +1,32 @@
+module Pod
+  class Installer
+    # Generates stable UUIDs for Native Targets.
+    #
+    class TargetUUIDGenerator < Xcodeproj::Project::UUIDGenerator
+      # This method override is used to ONLY generate stable UUIDs for PBXNativeTarget instances and no other type.
+      # Stable native target UUIDs are necessary for incremental installation because other projects reference the
+      # target by its UUID in the remoteGlobalIDString field.
+      #
+      # @param [Array<Project>] projects
+      #        The list of projects used to generate stabe target UUIDs.
+      #
+      def generate_all_paths_by_objects(projects)
+        @paths_by_object = {}
+        projects.each do |project|
+          project_basename = project.path.basename.to_s
+          project.objects.each do |object|
+            @paths_by_object[object] = if object.is_a? Xcodeproj::Project::Object::AbstractTarget
+                                         Digest::MD5.hexdigest(project_basename + object.name).upcase
+                                       else
+                                         object.uuid
+                                       end
+          end
+        end
+      end
+
+      def uuid_for_path(path)
+        path
+      end
+    end
+  end
+end

data/lib/cocoapods/installer/user_project_integrator.rb

@@ -13,10 +13,6 @@ module Pod
     class UserProjectIntegrator
       autoload :TargetIntegrator, 'cocoapods/installer/user_project_integrator/target_integrator'
 
-      include InstallationOptions::Mixin
-
-      delegate_installation_options { podfile }
-
       # @return [Podfile] the podfile that should be integrated with the user
       #         projects.
       #
@@ -41,6 +37,11 @@ module Pod
       #
       attr_reader :targets
 
+      # @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
+
       # Init a new UserProjectIntegrator
       #
       # @param  [Podfile]  podfile @see #podfile
@@ -48,11 +49,12 @@ module Pod
       # @param  [Pathname] installation_root @see #installation_root
       # @param  [Array<AggregateTarget>] targets @see #targets
       #
-      def initialize(podfile, sandbox, installation_root, targets)
+      def initialize(podfile, sandbox, installation_root, targets, use_input_output_paths: true)
         @podfile = podfile
         @sandbox = sandbox
         @installation_root = installation_root
         @targets = targets
+        @use_input_output_paths = use_input_output_paths
       end
 
       # Integrates the user projects associated with the {TargetDefinitions}
@@ -115,7 +117,7 @@ module Pod
       #
       def integrate_user_targets
         target_integrators = targets_to_integrate.sort_by(&:name).map do |target|
-          TargetIntegrator.new(target, installation_options)
+          TargetIntegrator.new(target, :use_input_output_paths => use_input_output_paths?)
         end
 
         Config.instance.with_changes(:silent => true) do

data/lib/cocoapods/installer/user_project_integrator/target_integrator.rb

@@ -49,21 +49,68 @@ module Pod
         #
         attr_reader :target
 
-        # @return [InstallationOptions] the installation options from the Podfile.
+        # @return [Boolean] whether to use input/output paths for build phase scripts
         #
-        attr_reader :installation_options
+        attr_reader :use_input_output_paths
+        alias use_input_output_paths? use_input_output_paths
 
         # Init a new TargetIntegrator
         #
         # @param  [AggregateTarget] target @see #target
-        # @param  [InstallationOptions] installation_options @see #installation_options
+        # @param  [Boolean] use_input_output_paths @see #use_input_output_paths
         #
-        def initialize(target, installation_options)
+        def initialize(target, use_input_output_paths: true)
           @target = target
-          @installation_options = installation_options
+          @use_input_output_paths = use_input_output_paths
         end
 
+        # @private
+        #
+        XCFileListConfigKey = Struct.new(:file_list_path, :file_list_relative_path)
+
         class << self
+          # @param  [Xcodeproj::Project::Object::AbstractObject] object
+          #
+          # @return [Boolean] Whether input & output paths for the given object
+          #         should be stored in a file list file.
+          #
+          def input_output_paths_use_filelist?(object)
+            object.project.object_version.to_i >= 50
+          end
+
+          # Sets the input & output paths for the given script build phase.
+          #
+          # @param  [Xcodeproj::Project::Object::PBXShellScriptBuildPhase] phase
+          #         The phase to set input & output paths on.
+          #
+          # @param  [Hash] input_paths_by_config
+          #
+          # @return [Void]
+          def set_input_output_paths(phase, input_paths_by_config, output_paths_by_config)
+            if input_output_paths_use_filelist?(phase)
+              [input_paths_by_config, output_paths_by_config].each do |hash|
+                hash.each do |file_list, files|
+                  generator = Generator::FileList.new(files)
+                  Xcode::PodsProjectGenerator::TargetInstallerHelper.update_changed_file(generator, file_list.file_list_path)
+                end
+              end
+
+              phase.input_paths = nil
+              phase.output_paths = nil
+              phase.input_file_list_paths = input_paths_by_config.each_key.map(&:file_list_relative_path).uniq
+              phase.output_file_list_paths = output_paths_by_config.each_key.map(&:file_list_relative_path).uniq
+            else
+              input_paths = input_paths_by_config.values.flatten(1).uniq
+              output_paths = output_paths_by_config.values.flatten(1).uniq
+              TargetIntegrator.validate_input_output_path_limit(input_paths, output_paths)
+
+              phase.input_paths = input_paths
+              phase.output_paths = output_paths
+              phase.input_file_list_paths = nil
+              phase.output_file_list_paths = nil
+            end
+          end
+
           # Adds a shell script build phase responsible to copy (embed) the frameworks
           # generated by the TargetDefinition to the bundle of the product of the
           # targets.
@@ -74,19 +121,18 @@ module Pod
           # @param [String] script_path
           #        The script path to execute as part of this script phase.
           #
-          # @param [Array<String>] input_paths
+          # @param [Hash<Array, String>] input_paths_by_config
           #        The input paths (if any) to include for this script phase.
           #
-          # @param [Array<String>] output_paths
+          # @param [Hash<Array, String>] output_paths_by_config
           #        The output paths (if any) to include for this script phase.
           #
           # @return [void]
           #
-          def create_or_update_embed_frameworks_script_phase_to_target(native_target, script_path, input_paths = [], output_paths = [])
-            phase = TargetIntegrator.create_or_update_build_phase(native_target, BUILD_PHASE_PREFIX + EMBED_FRAMEWORK_PHASE_NAME)
+          def create_or_update_embed_frameworks_script_phase_to_target(native_target, script_path, input_paths_by_config = {}, output_paths_by_config = {})
+            phase = TargetIntegrator.create_or_update_shell_script_build_phase(native_target, BUILD_PHASE_PREFIX + EMBED_FRAMEWORK_PHASE_NAME)
             phase.shell_script = %("#{script_path}"\n)
-            phase.input_paths = input_paths
-            phase.output_paths = output_paths
+            TargetIntegrator.set_input_output_paths(phase, input_paths_by_config, output_paths_by_config)
           end
 
           # Delete a 'Embed Pods Frameworks' Copy Files Build Phase if present
@@ -110,20 +156,19 @@ module Pod
           # @param [String] script_path
           #        The script path to execute as part of this script phase.
           #
-          # @param [Array<String>] input_paths
+          # @param [Hash<Array, String>] input_paths_by_config
           #        The input paths (if any) to include for this script phase.
           #
-          # @param [Array<String>] output_paths
+          # @param [Hash<Array, String>] output_paths_by_config
           #        The output paths (if any) to include for this script phase.
           #
           # @return [void]
           #
-          def create_or_update_copy_resources_script_phase_to_target(native_target, script_path, input_paths = [], output_paths = [])
+          def create_or_update_copy_resources_script_phase_to_target(native_target, script_path, input_paths_by_config = {}, output_paths_by_config = {})
             phase_name = COPY_PODS_RESOURCES_PHASE_NAME
-            phase = TargetIntegrator.create_or_update_build_phase(native_target, BUILD_PHASE_PREFIX + phase_name)
+            phase = TargetIntegrator.create_or_update_shell_script_build_phase(native_target, BUILD_PHASE_PREFIX + phase_name)
             phase.shell_script = %("#{script_path}"\n)
-            phase.input_paths = input_paths
-            phase.output_paths = output_paths
+            TargetIntegrator.set_input_output_paths(phase, input_paths_by_config, output_paths_by_config)
           end
 
           # Delete a 'Copy Pods Resources' script phase if present
@@ -142,21 +187,24 @@ module Pod
           # @param [PBXNativeTarget] native_target
           #        The native target to add the script phase into.
           #
-          # @param [String] phase_name
-          #        The name of the phase to use.
+          # @param [String] script_phase_name
+          #        The name of the script phase to use.
           #
-          # @param [Class] phase_class
-          #        The class of the phase to use.
+          # @param [String] show_env_vars_in_log
+          #        The value to set for show environment variables in the log during execution of this script phase or
+          #        `nil` for not setting the value at all.
           #
           # @return [void]
           #
-          def create_or_update_build_phase(native_target, phase_name, phase_class = Xcodeproj::Project::Object::PBXShellScriptBuildPhase)
-            build_phases = native_target.build_phases.grep(phase_class)
-            build_phases.find { |phase| phase.name && phase.name.end_with?(phase_name) }.tap { |p| p.name = phase_name if p } ||
-              native_target.project.new(phase_class).tap do |phase|
-                UI.message("Adding Build Phase '#{phase_name}' to project.") do
-                  phase.name = phase_name
-                  phase.show_env_vars_in_log = '0'
+          def create_or_update_shell_script_build_phase(native_target, script_phase_name, show_env_vars_in_log = '0')
+            build_phases = native_target.build_phases.grep(Xcodeproj::Project::Object::PBXShellScriptBuildPhase)
+            build_phases.find { |phase| phase.name && phase.name.end_with?(script_phase_name) }.tap { |p| p.name = script_phase_name if p } ||
+              native_target.project.new(Xcodeproj::Project::Object::PBXShellScriptBuildPhase).tap do |phase|
+                UI.message("Adding Build Phase '#{script_phase_name}' to project.") do
+                  phase.name = script_phase_name
+                  unless show_env_vars_in_log.nil?
+                    phase.show_env_vars_in_log = show_env_vars_in_log
+                  end
                   native_target.build_phases << phase
                 end
               end
@@ -180,12 +228,16 @@ module Pod
             # Create or update the ones that are expected to be.
             script_phases.each do |script_phase|
               name_with_prefix = USER_BUILD_PHASE_PREFIX + script_phase[:name]
-              phase = TargetIntegrator.create_or_update_build_phase(native_target, name_with_prefix)
+              phase = TargetIntegrator.create_or_update_shell_script_build_phase(native_target, name_with_prefix, nil)
               phase.shell_script = script_phase[:script]
-              phase.shell_path = script_phase[:shell_path] if script_phase.key?(:shell_path)
-              phase.input_paths = script_phase[:input_files] if script_phase.key?(:input_files)
-              phase.output_paths = script_phase[:output_files] if script_phase.key?(:output_files)
-              phase.show_env_vars_in_log = script_phase[:show_env_vars_in_log] ? '1' : '0' if script_phase.key?(:show_env_vars_in_log)
+              phase.shell_path = script_phase[:shell_path] || '/bin/sh'
+              phase.input_paths = script_phase[:input_files]
+              phase.output_paths = script_phase[:output_files]
+              # At least with Xcode 10 `showEnvVarsInLog` is *NOT* set to any value even if it's checked and it only
+              # gets set to '0' if the user has explicitly disabled this.
+              if (show_env_vars_in_log = script_phase.fetch(:show_env_vars_in_log, '1')) == '0'
+                phase.show_env_vars_in_log = show_env_vars_in_log
+              end
 
               execution_position = script_phase[:execution_position]
               unless execution_position == :any
@@ -321,22 +373,25 @@ module Pod
           frameworks = user_project.frameworks_group
           native_targets.each do |native_target|
             build_phase = native_target.frameworks_build_phase
+            product_name = target.product_name
+
+            # Delete previously integrated references.
+            product_build_files = build_phase.files.select do |build_file|
+              build_file.display_name =~ Pod::Deintegrator::FRAMEWORK_NAMES
+            end
 
-            # Find and delete possible reference for the other product type
-            old_product_name = target.requires_frameworks? ? target.static_library_name : target.framework_name
-            old_product_ref = frameworks.files.find { |f| f.path == old_product_name }
-            if old_product_ref.present?
-              UI.message("Removing old Pod product reference #{old_product_name} from project.")
-              build_phase.remove_file_reference(old_product_ref)
-              frameworks.remove_reference(old_product_ref)
+            product_build_files.each do |product_file|
+              next unless product_name != product_file.display_name
+              UI.message("Removing old product reference `#{product_file.display_name}` from project.")
+              frameworks.remove_reference(product_file.file_ref)
+              build_phase.remove_build_file(product_file)
             end
 
             # Find or create and add a reference for the current product type
-            target_basename = target.product_basename
-            new_product_ref = frameworks.files.find { |f| f.path == target.product_name } ||
-              frameworks.new_product_ref_for_target(target_basename, target.product_type)
+            new_product_ref = frameworks.files.find { |f| f.path == product_name } ||
+                frameworks.new_product_ref_for_target(target.product_basename, target.product_type)
             build_phase.build_file(new_product_ref) ||
-              build_phase.add_file_reference(new_product_ref, true)
+                build_phase.add_file_reference(new_product_ref, true)
           end
         end
 
@@ -351,20 +406,24 @@ module Pod
             end
             return
           end
+
           script_path = target.copy_resources_script_relative_path
-          input_paths = []
-          output_paths = []
-          unless installation_options.disable_input_output_paths?
-            resource_paths_by_config = target.resource_paths_by_config
-            resource_paths_flattened = resource_paths_by_config.values.flatten.uniq
-            input_paths = [target.copy_resources_script_relative_path, *resource_paths_flattened]
-            output_paths = TargetIntegrator.resource_output_paths(resource_paths_flattened)
+          input_paths_by_config = {}
+          output_paths_by_config = {}
+          if use_input_output_paths
+            target.resource_paths_by_config.each do |config, resource_paths|
+              input_paths_key = XCFileListConfigKey.new(target.copy_resources_script_input_files_path(config), target.copy_resources_script_input_files_relative_path)
+              input_paths_by_config[input_paths_key] = [script_path] + resource_paths
+
+              output_paths_key = XCFileListConfigKey.new(target.copy_resources_script_output_files_path(config), target.copy_resources_script_output_files_relative_path)
+              output_paths_by_config[output_paths_key] = TargetIntegrator.resource_output_paths(resource_paths)
+            end
           end
-          TargetIntegrator.validate_input_output_path_limit(input_paths, output_paths)
+
           native_targets.each do |native_target|
             # Static library targets cannot include resources. Skip this phase from being added instead.
             next if native_target.symbol_type == :static_library
-            TargetIntegrator.create_or_update_copy_resources_script_phase_to_target(native_target, script_path, input_paths, output_paths)
+            TargetIntegrator.create_or_update_copy_resources_script_phase_to_target(native_target, script_path, input_paths_by_config, output_paths_by_config)
           end
         end
 
@@ -394,19 +453,25 @@ module Pod
             end
             return
           end
+
           script_path = target.embed_frameworks_script_relative_path
-          input_paths = []
-          output_paths = []
-          unless installation_options.disable_input_output_paths?
-            framework_paths = target.framework_paths_by_config.values.flatten.uniq
-            framework_input_paths = framework_paths.flat_map { |path| [path.source_path, path.dsym_path] }.compact
-            input_paths = [target.embed_frameworks_script_relative_path, *framework_input_paths]
-            output_paths = TargetIntegrator.framework_output_paths(framework_paths)
-            TargetIntegrator.validate_input_output_path_limit(input_paths, output_paths)
+          input_paths_by_config = {}
+          output_paths_by_config = {}
+          if use_input_output_paths?
+            target.framework_paths_by_config.each do |config, framework_paths|
+              input_paths_key = XCFileListConfigKey.new(target.embed_frameworks_script_input_files_path(config), target.embed_frameworks_script_input_files_relative_path)
+              input_paths = input_paths_by_config[input_paths_key] = [script_path]
+              framework_paths.each do |path|
+                input_paths.concat(path.all_paths)
+              end
+
+              output_paths_key = XCFileListConfigKey.new(target.embed_frameworks_script_output_files_path(config), target.embed_frameworks_script_output_files_relative_path)
+              output_paths_by_config[output_paths_key] = TargetIntegrator.framework_output_paths(framework_paths)
+            end
           end
 
           native_targets_to_embed_in.each do |native_target|
-            TargetIntegrator.create_or_update_embed_frameworks_script_phase_to_target(native_target, script_path, input_paths, output_paths)
+            TargetIntegrator.create_or_update_embed_frameworks_script_phase_to_target(native_target, script_path, input_paths_by_config, output_paths_by_config)
           end
         end
 
@@ -433,7 +498,7 @@ module Pod
         def add_check_manifest_lock_script_phase
           phase_name = CHECK_MANIFEST_PHASE_NAME
           native_targets.each do |native_target|
-            phase = TargetIntegrator.create_or_update_build_phase(native_target, BUILD_PHASE_PREFIX + phase_name)
+            phase = TargetIntegrator.create_or_update_shell_script_build_phase(native_target, BUILD_PHASE_PREFIX + phase_name)
             native_target.build_phases.unshift(phase).uniq! unless native_target.build_phases.first == phase
             phase.shell_script = <<-SH.strip_heredoc
               diff "${PODS_PODFILE_DIR_PATH}/Podfile.lock" "${PODS_ROOT}/Manifest.lock" > /dev/null