cocoapods 1.6.2 → 1.7.0.beta.1

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

@@ -10,18 +10,19 @@ module Pod
           #
           attr_reader :target_installation_result
 
-          # @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
 
           # Initialize a new instance
           #
           # @param  [TargetInstallationResult] target_installation_result @see #target_installation_result
-          # @param  [InstallationOptions] installation_options @see #installation_options
+          # @param  [Boolean] use_input_output_paths @see #use_input_output_paths
           #
-          def initialize(target_installation_result, installation_options)
+          def initialize(target_installation_result, use_input_output_paths: true)
             @target_installation_result = target_installation_result
-            @installation_options = installation_options
+            @use_input_output_paths = use_input_output_paths
           end
 
           # Integrates the pod target.
@@ -30,15 +31,12 @@ module Pod
           #
           def integrate!
             UI.section(integration_message) do
-              target_installation_result.test_specs_by_native_target.each do |test_native_target, test_specs|
-                test_specs.each do |test_spec|
-                  add_embed_frameworks_script_phase(test_native_target, test_spec)
-                  add_copy_resources_script_phase(test_native_target, test_spec)
-                end
-                UserProjectIntegrator::TargetIntegrator.create_or_update_user_script_phases(script_phases_for_specs(test_specs), test_native_target)
+              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)
+                UserProjectIntegrator::TargetIntegrator.create_or_update_user_script_phases(script_phases_for_specs(spec), native_target)
               end
-              specs = target.non_test_specs
-              UserProjectIntegrator::TargetIntegrator.create_or_update_user_script_phases(script_phases_for_specs(specs), 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
 
@@ -57,48 +55,77 @@ module Pod
           #
           # @return [void]
           #
-          def add_copy_resources_script_phase(native_target, test_spec)
-            script_path = "${PODS_ROOT}/#{target.copy_resources_script_path_for_test_spec(test_spec).relative_path_from(target.sandbox.root)}"
-            input_paths = []
-            output_paths = []
-            unless installation_options.disable_input_output_paths?
-              resource_paths = target.dependent_targets_for_test_spec(test_spec).flat_map do |dependent_target|
-                spec_paths_to_include = dependent_target.non_test_specs.map(&:name)
-                spec_paths_to_include << test_spec.name if dependent_target == target
+          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 = {}
+            if use_input_output_paths
+              dependent_targets = if spec.test_specification?
+                                    target.dependent_targets_for_test_spec(spec)
+                                  else
+                                    target.dependent_targets_for_app_spec(spec)
+                                  end
+              resource_paths = dependent_targets.flat_map do |dependent_target|
+                spec_paths_to_include = dependent_target.library_specs.map(&:name)
+                spec_paths_to_include << spec.name if dependent_target == target
                 dependent_target.resource_paths.values_at(*spec_paths_to_include).flatten.compact
-              end
+              end.uniq
+
               unless resource_paths.empty?
-                resource_paths_flattened = resource_paths.flatten.uniq
-                input_paths = [script_path, *resource_paths_flattened]
-                output_paths = UserProjectIntegrator::TargetIntegrator.resource_output_paths(resource_paths_flattened)
+                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
             end
-            UserProjectIntegrator::TargetIntegrator.validate_input_output_path_limit(input_paths, output_paths)
-            UserProjectIntegrator::TargetIntegrator.create_or_update_copy_resources_script_phase_to_target(native_target, script_path, input_paths, output_paths)
+
+            UserProjectIntegrator::TargetIntegrator.create_or_update_copy_resources_script_phase_to_target(native_target, script_path, input_paths_by_config, output_paths_by_config)
           end
 
           # Find or create a 'Embed Pods Frameworks' Copy Files Build Phase
           #
           # @return [void]
           #
-          def add_embed_frameworks_script_phase(native_target, test_spec)
-            script_path = "${PODS_ROOT}/#{target.embed_frameworks_script_path_for_test_spec(test_spec).relative_path_from(target.sandbox.root)}"
-            input_paths = []
-            output_paths = []
-            unless installation_options.disable_input_output_paths?
-              framework_paths = target.dependent_targets_for_test_spec(test_spec).flat_map do |dependent_target|
-                spec_paths_to_include = dependent_target.non_test_specs.map(&:name)
-                spec_paths_to_include << test_spec.name if dependent_target == target
-                dependent_target.framework_paths.values_at(*spec_paths_to_include).flatten.compact.uniq
-              end
+          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 = {}
+            if use_input_output_paths?
+              dependent_targets = if spec.test_specification?
+                                    target.dependent_targets_for_test_spec(spec)
+                                  else
+                                    target.dependent_targets_for_app_spec(spec)
+                                  end
+              framework_paths = dependent_targets.flat_map do |dependent_target|
+                spec_paths_to_include = dependent_target.library_specs.map(&:name)
+                spec_paths_to_include << spec.name if dependent_target == target
+                dependent_target.framework_paths.values_at(*spec_paths_to_include).flatten.compact
+              end.uniq
+
               unless framework_paths.empty?
-                input_paths = [script_path, *framework_paths.flat_map { |fw| [fw.source_path, fw.dsym_path] }.compact]
-                output_paths = UserProjectIntegrator::TargetIntegrator.framework_output_paths(framework_paths)
+                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 = input_paths_by_config[input_paths_key] = [script_path]
+                framework_paths.each do |path|
+                  input_paths.concat(path.all_paths)
+                end
+
+                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.framework_output_paths(framework_paths)
               end
             end
 
-            UserProjectIntegrator::TargetIntegrator.validate_input_output_path_limit(input_paths, output_paths)
-            UserProjectIntegrator::TargetIntegrator.create_or_update_embed_frameworks_script_phase_to_target(native_target, script_path, input_paths, output_paths)
+            UserProjectIntegrator::TargetIntegrator.create_or_update_embed_frameworks_script_phase_to_target(native_target, script_path, input_paths_by_config, output_paths_by_config)
           end
 
           # @return [String] the message that should be displayed for the target
@@ -114,13 +141,13 @@ module Pod
             target_installation_result.target
           end
 
-          # @param [Array<Specification] specs
+          # @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)
-            specs.flat_map { |spec| spec.consumer(target.platform).script_phases }
+            Array(specs).flat_map { |spec| spec.consumer(target.platform).script_phases }
           end
         end
       end

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

@@ -0,0 +1,75 @@
+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
+
+        def write!
+          cleanup_projects(projects)
+
+          projects.each do |project|
+            UI.message "- Writing Xcode project file to #{UI.path project.path}" do
+              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
+              project.save
+            end
+          end
+        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? }
+            project.sort(:groups_position => :below)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+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 [String] 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 [String] 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'
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -38,6 +38,18 @@ module Pod
           #
           attr_reader :test_app_host_targets
 
+          # @return [Array<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
@@ -46,15 +58,20 @@ module Pod
           # @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 [Array<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 = [])
+                         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.
@@ -65,20 +82,34 @@ module Pod
           # @return [PBXNativeTarget] the native target to use or `nil` if none is found.
           #
           def native_target_for_spec(spec)
-            return native_target unless spec.test_specification?
-            test_native_target_from_spec(spec)
+            return native_target if spec.library_specification?
+            return test_native_target_from_spec(spec) if spec.test_specification?
+            return 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
-          #         an array of all the test specs associated with this native target.
+          #         is the test spec associated with this native target.
           #
           def test_specs_by_native_target
-            test_specs_by_native_target = target.test_specs.group_by do |test_spec|
-              test_native_target_from_spec(test_spec)
-            end
+            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
+
           private
 
           def test_native_target_from_spec(spec)
@@ -86,6 +117,12 @@ module Pod
               test_native_target.name == target.test_target_label(spec)
             end
           end
+
+          def app_native_target_from_spec(spec)
+            app_native_targets.find do |app_native_target|
+              app_native_target.name == target.app_target_label(spec)
+            end
+          end
         end
       end
     end