cocoapods 1.6.2 → 1.7.0.beta.1

data/lib/cocoapods/installer/xcode.rb

@@ -2,6 +2,9 @@ module Pod
   class Installer
     class Xcode
       autoload :PodsProjectGenerator, 'cocoapods/installer/xcode/pods_project_generator'
+      autoload :SinglePodsProjectGenerator, 'cocoapods/installer/xcode/single_pods_project_generator'
+      autoload :MultiPodsProjectGenerator, 'cocoapods/installer/xcode/multi_pods_project_generator'
+      autoload :PodsProjectWriter, 'cocoapods/installer/xcode/pods_project_generator/pods_project_writer'
       autoload :TargetValidator, 'cocoapods/installer/xcode/target_validator'
     end
   end

data/lib/cocoapods/installer/xcode/multi_pods_project_generator.rb

@@ -0,0 +1,72 @@
+module Pod
+  class Installer
+    class Xcode
+      # The {MultiPodsProjectGenerator} handles generation of the 'Pods/Pods.xcodeproj' and Xcode projects
+      # for every {PodTarget}. All Pod Target projects are nested under the 'Pods.xcodeproj'.
+      #
+      class MultiPodsProjectGenerator < PodsProjectGenerator
+        # Generates `Pods/Pods.xcodeproj` and all pod target subprojects.
+        #
+        # @return [PodsProjectGeneratorResult]
+        #
+        def generate!
+          # Generate container Pods.xcodeproj.
+          container_project = create_container_project(aggregate_targets, sandbox.project_path)
+
+          project_paths_by_pod_targets = pod_targets.group_by { |pod_target| sandbox.pod_target_project_path(pod_target.pod_name) }
+          projects_by_pod_targets = Hash[project_paths_by_pod_targets.map do |project_path, pod_targets|
+            project = create_pods_project(pod_targets, project_path, container_project)
+            [project, pod_targets]
+          end]
+
+          # Note: We must call `install_file_references` on all pod targets before installing them.
+          pod_target_installation_results = install_all_pod_targets(projects_by_pod_targets)
+          aggregate_target_installation_results = install_aggregate_targets_into_project(container_project, aggregate_targets)
+          target_installation_results = InstallationResults.new(pod_target_installation_results, aggregate_target_installation_results)
+
+          integrate_targets(target_installation_results.pod_target_installation_results)
+          wire_target_dependencies(target_installation_results)
+          PodsProjectGeneratorResult.new(container_project, projects_by_pod_targets, target_installation_results)
+        end
+
+        private
+
+        def create_container_project(aggregate_targets, path)
+          return unless aggregate_targets
+          platforms = aggregate_targets.map(&:platform)
+          ProjectGenerator.new(sandbox, path, [], build_configurations, platforms,
+                               project_object_version, config.podfile_path).generate!
+        end
+
+        def create_pods_project(pod_targets, path, parent_project)
+          platforms = pod_targets.map(&:platform)
+          project = ProjectGenerator.new(sandbox, path,
+                                         pod_targets, build_configurations, platforms,
+                                         project_object_version, false, :pod_target_subproject => true).generate!
+          # Instead of saving every subproject to disk, we can optimize this by creating a temporary folder
+          # the file reference can use so that we only have to call `save` once for all projects.
+          project.path.mkpath
+          if parent_project
+            parent_project.add_subproject_reference(project, parent_project.dependencies_group)
+          end
+
+          install_file_references(project, pod_targets)
+          project
+        end
+
+        def install_all_pod_targets(projects_by_pod_targets)
+          UI.message '- Installing Pod Targets' do
+            projects_by_pod_targets.each_with_object({}) do |(project, pod_targets), target_installation_results|
+              target_installation_results.merge!(install_pod_targets(project, pod_targets))
+            end
+          end
+        end
+
+        def install_aggregate_targets_into_project(project, aggregate_targets)
+          return {} unless project
+          install_aggregate_targets(project, aggregate_targets)
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 module Pod
   class Installer
     class Xcode
-      # The {PodsProjectGenerator} handles generation of the 'Pods/Pods.xcodeproj'
+      # The {PodsProjectGenerator} handles generation of CocoaPods Xcode projects.
       #
       class PodsProjectGenerator
         require 'cocoapods/installer/xcode/pods_project_generator/target_installer_helper'
@@ -11,15 +11,16 @@ module Pod
         require 'cocoapods/installer/xcode/pods_project_generator/pod_target_installer'
         require 'cocoapods/installer/xcode/pods_project_generator/file_references_installer'
         require 'cocoapods/installer/xcode/pods_project_generator/aggregate_target_installer'
+        require 'cocoapods/installer/xcode/pods_project_generator/project_generator'
+        require 'cocoapods/installer/xcode/pods_project_generator_result'
+        require 'cocoapods/installer/xcode/pods_project_generator/aggregate_target_dependency_installer'
+        require 'cocoapods/installer/xcode/pods_project_generator/pod_target_dependency_installer'
+        require 'cocoapods/native_target_extension.rb'
 
         # @return [Sandbox] The sandbox where the Pods should be installed.
         #
         attr_reader :sandbox
 
-        # @return [Pod::Project] the `Pods/Pods.xcodeproj` project.
-        #
-        attr_reader :project
-
         # @return [Array<AggregateTarget>] The model representations of an
         #         aggregation of pod targets generated for a target definition
         #         in the Podfile.
@@ -30,10 +31,9 @@ module Pod
         #
         attr_reader :pod_targets
 
-        # @return [Analyzer] the analyzer which provides the information about what
-        #         needs to be installed.
+        # @return [Hash{String => Symbol}] The build configurations that need to be installed.
         #
-        attr_reader :analysis_result
+        attr_reader :build_configurations
 
         # @return [InstallationOptions] the installation options from the Podfile.
         #
@@ -43,175 +43,113 @@ module Pod
         #
         attr_reader :config
 
-        # Initialize a new instance
+        # @return [String] the object version for the projects we will generate.
         #
-        # @param  [Sandbox]                sandbox               @see #sandbox
-        # @param  [Array<AggregateTarget>] aggregate_targets     @see #aggregate_targets
-        # @param  [Array<PodTarget>]       pod_targets           @see #pod_targets
-        # @param  [Analyzer]               analysis_result       @see #analysis_result
-        # @param  [InstallationOptions]    installation_options  @see #installation_options
-        # @param  [Config]                 config                @see #config
+        attr_reader :project_object_version
+
+        # @return [ProjectMetadataCache] the metadata cache used to reconstruct target dependencies.
         #
-        def initialize(sandbox, aggregate_targets, pod_targets, analysis_result, installation_options, config)
+        attr_reader :metadata_cache
+
+        # Initialize a new instance
+        #
+        # @param  [Sandbox]                sandbox                @see #sandbox
+        # @param  [Array<AggregateTarget>] aggregate_targets      @see #aggregate_targets
+        # @param  [Array<PodTarget>]       pod_targets            @see #pod_targets
+        # @param  [Hash{String => Symbol}] build_configurations   @see #build_configurations
+        # @param  [InstallationOptions]    installation_options   @see #installation_options
+        # @param  [Config]                 config                 @see #config
+        # @param  [String]                 project_object_version @see #project_object_version
+        # @param  [ProjectMetadataCache]   metadata_cache         @see #metadata_cache
+        #
+        def initialize(sandbox, aggregate_targets, pod_targets, build_configurations, installation_options, config,
+                       project_object_version, metadata_cache = nil)
           @sandbox = sandbox
           @aggregate_targets = aggregate_targets
           @pod_targets = pod_targets
-          @analysis_result = analysis_result
+          @build_configurations = build_configurations
           @installation_options = installation_options
           @config = config
-        end
-
-        def generate!
-          prepare
-          install_file_references
-          @target_installation_results = install_targets
-          integrate_targets(@target_installation_results.pod_target_installation_results)
-          wire_target_dependencies(@target_installation_results)
-          @target_installation_results
-        end
-
-        def write
-          UI.message "- Writing Xcode project file to #{UI.path sandbox.project_path}" do
-            project.pods.remove_from_project if project.pods.empty?
-            project.development_pods.remove_from_project if project.development_pods.empty?
-            project.sort(:groups_position => :below)
-            if installation_options.deterministic_uuids?
-              UI.message('- Generating deterministic UUIDs') { project.predictabilize_uuids }
-            end
-            library_product_types = [:framework, :dynamic_library, :static_library]
-
-            pod_target_installation_results = @target_installation_results.pod_target_installation_results
-            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
+          @project_object_version = project_object_version
+          @metadata_cache = metadata_cache
         end
 
         # Shares schemes of development Pods.
         #
         # @return [void]
         #
-        def share_development_pod_schemes
-          development_pod_targets.select(&:should_build?).each do |pod_target|
-            next unless share_scheme_for_development_pod?(pod_target.pod_name)
-            Xcodeproj::XCScheme.share_scheme(project.path, pod_target.label)
-            if pod_target.contains_test_specifications?
-              pod_target.test_specs.each do |test_spec|
-                Xcodeproj::XCScheme.share_scheme(project.path, pod_target.test_target_label(test_spec))
-              end
-            end
+        def share_development_pod_schemes(project, development_pod_targets = [])
+          targets = development_pod_targets.select do |target|
+            target.should_build? && share_scheme_for_development_pod?(target.pod_name)
+          end
+          targets.each do |pod_target|
+            configure_schemes_for_pod_target(project, pod_target)
           end
         end
 
-        private
-
+        # @!attribute [Hash{String => TargetInstallationResult}] pod_target_installation_results
+        # @!attribute [Hash{String => TargetInstallationResult}] aggregate_target_installation_results
         InstallationResults = Struct.new(:pod_target_installation_results, :aggregate_target_installation_results)
 
-        def create_project
-          if object_version = aggregate_targets.map(&:user_project).compact.map { |p| p.object_version.to_i }.min
-            Pod::Project.new(sandbox.project_path, false, object_version)
-          else
-            Pod::Project.new(sandbox.project_path)
+        private
+
+        def install_file_references(project, pod_targets)
+          UI.message "- Installing files into #{project.project_name} project" do
+            installer = FileReferencesInstaller.new(sandbox, pod_targets, project, installation_options.preserve_pod_file_structure)
+            installer.install!
           end
         end
 
-        # Creates the Pods project from scratch if it doesn't exists.
-        #
-        # @return [void]
-        #
-        # @todo   Clean and modify the project if it exists.
-        #
-        def prepare
-          UI.message '- Creating Pods project' do
-            @project = create_project
-            analysis_result.all_user_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
+        def install_pod_targets(project, pod_targets)
+          umbrella_headers_by_dir = pod_targets.map do |pod_target|
+            next unless pod_target.should_build? && pod_target.defines_module?
+            pod_target.umbrella_header_path
+          end.compact.group_by(&:dirname)
 
-            if config.podfile_path
-              @project.add_podfile(config.podfile_path)
-            end
+          pod_target_installation_results = Hash[pod_targets.sort_by(&:name).map do |pod_target|
+            umbrella_headers_in_header_dir = umbrella_headers_by_dir[pod_target.module_map_path.dirname]
+            target_installer = PodTargetInstaller.new(sandbox, project, pod_target, umbrella_headers_in_header_dir)
+            [pod_target.name, target_installer.install!]
+          end]
 
-            sandbox.project = @project
-            platforms = aggregate_targets.map(&:platform)
-            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
+          # Hook up system framework dependencies for the pod targets that were just installed.
+          pod_target_installation_result_values = pod_target_installation_results.values.compact
+          unless pod_target_installation_result_values.empty?
+            add_system_framework_dependencies(pod_target_installation_result_values)
           end
-        end
 
-        def install_file_references
-          installer = FileReferencesInstaller.new(sandbox, pod_targets, project, installation_options.preserve_pod_file_structure)
-          installer.install!
+          pod_target_installation_results
         end
 
-        def install_targets
-          UI.message '- Installing targets' do
-            umbrella_headers_by_dir = pod_targets.map do |pod_target|
-              next unless pod_target.should_build? && pod_target.defines_module?
-              pod_target.umbrella_header_path
-            end.compact.group_by(&:dirname)
-
-            pod_target_installation_results = Hash[pod_targets.sort_by(&:name).map do |pod_target|
-              umbrella_headers_in_header_dir = umbrella_headers_by_dir[pod_target.module_map_path.dirname]
-              target_installer = PodTargetInstaller.new(sandbox, @project, pod_target, umbrella_headers_in_header_dir)
-              [pod_target.name, target_installer.install!]
-            end]
-
-            # Hook up system framework dependencies for the pod targets that were just installed.
-            pod_target_installation_result_values = pod_target_installation_results.values.compact
-            unless pod_target_installation_result_values.empty?
-              add_system_framework_dependencies(pod_target_installation_result_values)
-            end
-
+        def install_aggregate_targets(project, aggregate_targets)
+          UI.message '- Installing Aggregate Targets' do
             aggregate_target_installation_results = Hash[aggregate_targets.sort_by(&:name).map do |target|
-              target_installer = AggregateTargetInstaller.new(sandbox, @project, target)
+              target_installer = AggregateTargetInstaller.new(sandbox, project, target)
               [target.name, target_installer.install!]
             end]
 
-            InstallationResults.new(pod_target_installation_results, aggregate_target_installation_results)
+            aggregate_target_installation_results
           end
         end
 
+        # @param [Hash{String => InstallationResult}] pod_target_installation_results
+        #        the installations to integrate
+        #
+        # @return [void]
+        #
         def integrate_targets(pod_target_installation_results)
           pod_installations_to_integrate = pod_target_installation_results.values.select do |pod_target_installation_result|
             pod_target = pod_target_installation_result.target
-            !pod_target_installation_result.test_native_targets.empty? || pod_target.contains_script_phases?
+            !pod_target_installation_result.test_native_targets.empty? ||
+                !pod_target_installation_result.app_native_targets.empty? ||
+                pod_target.contains_script_phases?
           end
-          unless pod_installations_to_integrate.empty?
-            UI.message '- Integrating targets' do
-              pod_installations_to_integrate.each do |pod_target_installation_result|
-                PodTargetIntegrator.new(pod_target_installation_result, installation_options).integrate!
-              end
+          return if pod_installations_to_integrate.empty?
+
+          UI.message '- Integrating targets' do
+            use_input_output_paths = !installation_options.disable_input_output_paths
+            pod_installations_to_integrate.each do |pod_target_installation_result|
+              PodTargetIntegrator.new(pod_target_installation_result, :use_input_output_paths => use_input_output_paths).integrate!
             end
           end
         end
@@ -223,7 +161,7 @@ module Pod
           sorted_installation_results.each do |target_installation_result|
             pod_target = target_installation_result.target
             next unless pod_target.should_build?
-            next if !pod_target.requires_frameworks? || pod_target.static_framework?
+            next if pod_target.build_as_static?
             pod_target.file_accessors.each do |file_accessor|
               native_target = target_installation_result.native_target_for_spec(file_accessor.spec)
               add_system_frameworks_to_native_target(native_target, file_accessor)
@@ -241,65 +179,13 @@ module Pod
         # @return [void]
         #
         def wire_target_dependencies(target_installation_results)
-          frameworks_group = project.frameworks_group
           pod_target_installation_results_hash = target_installation_results.pod_target_installation_results
           aggregate_target_installation_results_hash = target_installation_results.aggregate_target_installation_results
 
-          # Wire up aggregate targets
-          aggregate_target_installation_results_hash.values.each do |aggregate_target_installation_result|
-            aggregate_target = aggregate_target_installation_result.target
-            aggregate_native_target = aggregate_target_installation_result.native_target
-            is_app_extension = !(aggregate_target.user_targets.map(&:symbol_type) &
-                [:app_extension, :watch_extension, :watch2_extension, :tv_extension, :messages_extension]).empty?
-            is_app_extension ||= aggregate_target.user_targets.any? { |ut| ut.common_resolved_build_setting('APPLICATION_EXTENSION_API_ONLY') == 'YES' }
-            configure_app_extension_api_only_to_native_target(aggregate_native_target) if is_app_extension
-            # Wire up dependencies that are part of inherit search paths for this aggregate target.
-            aggregate_target.search_paths_aggregate_targets.each do |search_paths_target|
-              aggregate_native_target.add_dependency(aggregate_target_installation_results_hash[search_paths_target.name].native_target)
-            end
-            # Wire up all pod target dependencies to aggregate target.
-            aggregate_target.pod_targets.each do |pod_target|
-              pod_target_native_target = pod_target_installation_results_hash[pod_target.name].native_target
-              aggregate_native_target.add_dependency(pod_target_native_target)
-              configure_app_extension_api_only_to_native_target(pod_target_native_target) if is_app_extension
-            end
-          end
+          AggregateTargetDependencyInstaller.new(aggregate_target_installation_results_hash,
+                                                 pod_target_installation_results_hash, metadata_cache).install!
 
-          # Wire up pod targets
-          pod_target_installation_results_hash.values.each do |pod_target_installation_result|
-            pod_target = pod_target_installation_result.target
-            native_target = pod_target_installation_result.native_target
-            # First, wire up all resource bundles.
-            pod_target_installation_result.resource_bundle_targets.each do |resource_bundle_target|
-              native_target.add_dependency(resource_bundle_target)
-              if pod_target.requires_frameworks? && pod_target.should_build?
-                native_target.add_resources([resource_bundle_target.product_reference])
-              end
-            end
-            # Wire up all dependencies to this pod target, if any.
-            dependent_targets = pod_target.dependent_targets
-            dependent_targets.each do |dependent_target|
-              native_target.add_dependency(pod_target_installation_results_hash[dependent_target.name].native_target)
-              add_framework_file_reference_to_native_target(native_target, pod_target, dependent_target, frameworks_group)
-            end
-            # Wire up test native targets.
-            unless pod_target_installation_result.test_native_targets.empty?
-              pod_target_installation_result.test_specs_by_native_target.each do |test_native_target, test_specs|
-                test_dependent_targets = test_specs.flat_map { |s| pod_target.test_dependent_targets_by_spec_name[s.name] }.compact.unshift(pod_target).uniq
-                test_dependent_targets.each do |test_dependent_target|
-                  dependency_installation_result = pod_target_installation_results_hash[test_dependent_target.name]
-                  resource_bundle_native_targets = dependency_installation_result.test_resource_bundle_targets[test_specs.first.name]
-                  unless resource_bundle_native_targets.nil?
-                    resource_bundle_native_targets.each do |test_resource_bundle_target|
-                      test_native_target.add_dependency(test_resource_bundle_target)
-                    end
-                  end
-                  test_native_target.add_dependency(dependency_installation_result.native_target)
-                  add_framework_file_reference_to_native_target(test_native_target, pod_target, test_dependent_target, frameworks_group)
-                end
-              end
-            end
-          end
+          PodTargetDependencyInstaller.new(pod_target_installation_results_hash, metadata_cache).install!
         end
 
         # @param  [String] pod The root name of the development pod.
@@ -320,15 +206,6 @@ module Pod
           end
         end
 
-        # @return [Array<Library>] The targets of the development pods generated by
-        #         the installation process.
-        #
-        def development_pod_targets
-          pod_targets.select do |pod_target|
-            sandbox.local?(pod_target.pod_name)
-          end
-        end
-
         #------------------------------------------------------------------------#
 
         # @! group Private Helpers
@@ -339,20 +216,27 @@ module Pod
           end
         end
 
-        def add_framework_file_reference_to_native_target(native_target, pod_target, dependent_target, frameworks_group)
-          if pod_target.should_build? && pod_target.requires_frameworks? && !pod_target.static_framework? && dependent_target.should_build?
-            product_ref = frameworks_group.files.find { |f| f.path == dependent_target.product_name } ||
-                frameworks_group.new_product_ref_for_target(dependent_target.product_basename, dependent_target.product_type)
-            native_target.frameworks_build_phase.add_file_reference(product_ref, true)
-          end
-        end
-
-        # Sets the APPLICATION_EXTENSION_API_ONLY build setting to YES for all
-        # configurations of the given native target.
-        #
-        def configure_app_extension_api_only_to_native_target(native_target)
-          native_target.build_configurations.each do |config|
-            config.build_settings['APPLICATION_EXTENSION_API_ONLY'] = 'YES'
+        def configure_schemes_for_pod_target(project, pod_target)
+          specs = [pod_target.root_spec] + pod_target.test_specs + pod_target.app_specs
+          specs.each do |spec|
+            scheme_name = spec.spec_type == :library ? pod_target.label : pod_target.non_library_spec_label(spec)
+            scheme_configuration = pod_target.scheme_for_spec(spec)
+            unless scheme_configuration.empty?
+              scheme_path = Xcodeproj::XCScheme.user_data_dir(project.path) + "#{scheme_name}.xcscheme"
+              scheme = Xcodeproj::XCScheme.new(scheme_path)
+              command_line_arguments = scheme.launch_action.command_line_arguments
+              scheme_configuration.fetch(:launch_arguments, []).each do |launch_arg|
+                command_line_arguments.assign_argument(:argument => launch_arg, :enabled => true)
+              end
+              scheme.launch_action.command_line_arguments = command_line_arguments
+              environment_variables = scheme.launch_action.environment_variables
+              scheme_configuration.fetch(:environment_variables, {}).each do |k, v|
+                environment_variables.assign_variable(:key => k, :value => v)
+              end
+              scheme.launch_action.environment_variables = environment_variables
+              scheme.save!
+            end
+            Xcodeproj::XCScheme.share_scheme(project.path, scheme_name)
           end
         end
       end