[PodsProjectGenerator] Major improvements

lib/cocoapods/installer/pods_project_generator.rb

@@ -4,6 +4,74 @@ module Pod
     # Generates the Pods project according to the targets identified by the
     # analyzer.
     #
+    # # Incremental editing
+    #
+    # The generator will edit exiting projects instead of recreating them from
+    # scratch. This behaviour significantly complicates the logic but leads to
+    # dramatic performance benefits for the installation times. Another feature
+    # of the incremental editing is the preservation of the UUIDs in the
+    # project which allows to easily compare projects, reduce SCM noise (if the
+    # CocoaPods artifacts are kept under source control), and finally, to
+    # improve indexing and build time in Xcode.
+    #
+    # ## Assumptions
+    #
+    # To tame the complexity of the incremental editing, the generator relies
+    # on the following assumptions:
+    #
+    # - The file references of the Pods are all stored in a dedicated group.
+    # - The support files for a Pod are stored in a group which in turn is
+    #   namespaced per aggregate target.
+    # - The support files of an aggregate target are stored in its group.
+    # - The support files generator is incremental and doesn't duplicates file
+    #   references.
+    #
+    # ## Logic overview
+    #
+    # 1. The pods project is prepared.
+    #    - The Pods project is generated from scratch if needed.
+    #    - Otherwise the project is recreated from scratch and cleaned.
+    #      - Existing native targets are matched to the targets.
+    #      - Unrecognized targets are removed with any reference to them in the
+    #        build phases of their other targets (dependencies build phases and
+    #        frameworks build phases).
+    #       - Unrecognized pod groups are removed.
+    # 2. All the targets which require it are installed.
+    # 3. The support files of the targets are generated and the file references
+    #    are created if needed.
+    # 4. Any missing Pod target is added to the framework build phases of the
+    #    dependent aggregate targets.
+    # 5. Any missing target is added to the dependencies build phase of the
+    #    dependent target.
+    #
+    # ## Caveats & Notes
+    #
+    # - Until CocoaPods 1.0 a migrator will not be provided and when the
+    #   structure of the Pods project changes it should be recreated from
+    #   scratch.
+    # - Although the incremental generation is reasonably robust, if the user
+    #   tampers with the Pods project an generation from scratch might be
+    #   necessary to bring the project to a consistent state.
+    # - Advanced users might workaround to missing features of CocoaPods
+    #   editing the project. Those customization might persist for a longer
+    #   time than in a system where the project is generated from scratch every
+    #   time.
+    # - If a Pod changes on any target it needs to be reinstalled from scratch
+    #   as the file references might change according to the platform and the
+    #   file references installer is not incremental.
+    # - The recreation of the target environment header forces the
+    #   recompilation of the project.
+    #
+    #
+    # TODO: Resource bundle targets are currently removed as they are not
+    #       unrecognized.
+    # TODO: Rebuild from scratch if the version of CocoaPods is not compatible.
+    # TODO: The paths of frameworks might not match in different systems.
+    # TODO: The recreation of the prefix header of the Pods targets forces a
+    #       recompilation.
+    # TODO: The headers search paths of the Pods xcconfigs should not include
+    #       all the headers.
+    #
     class PodsProjectGenerator
 
       autoload :AggregateTargetInstaller, 'cocoapods/installer/pods_project_generator/target_installer/aggregate_target_installer'
@@ -45,27 +113,27 @@ module Pod
       #
       def install
         prepare_project
-        sync_pod_targets
-        sync_aggregate_targets
-        sync_target_dependencies
-        sync_aggregate_targets_libraries
+        install_targets
+        sync_support_files
+        add_missing_aggregate_targets_libraries
+        add_missing_target_dependencies
       end
 
-      # @return [Project] the generated Pods project.
-      #
-      attr_reader :project
-
       # Writes the Pods project to the disk.
       #
       # @return [void]
       #
       def write_project
-        UI.message "- Writing Xcode project file" do
+        UI.message "- Writing Pods project" do
           project.prepare_for_serialization
           project.save
         end
       end
 
+      # @return [Project] the generated Pods project.
+      #
+      attr_reader :project
+
 
       private
 
@@ -85,8 +153,9 @@ module Pod
         else
           UI.message"- Opening existing project" do
             @project = Pod::Project.open(sandbox.project_path)
-            remove_groups
             detect_native_targets
+            clean_groups
+            clean_native_targets
           end
         end
 
@@ -95,100 +164,41 @@ module Pod
         sandbox.project = project
       end
 
-      def remove_groups
-        pod_names = all_pod_targets.map(&:pod_name).uniq.sort
-        groups_to_remove = []
-        groups_to_remove << project.pod_groups.reject do |group|
-          pod_names.include?(group.display_name)
-        end
-
-        groups_to_remove << project.aggregate_groups.map(&:groups).flatten.reject do |group|
-          pod_names.include?(group.display_name)
-        end
-
-        aggregate_names = aggregate_targets.map(&:label).uniq.sort
-        groups_to_remove << project.support_files_group.children.reject do |group|
-          aggregate_names.include?(group.display_name)
-        end
-
-        groups_to_remove.flatten.each do |group|
-          p group
-          remove_group(group)
-        end
-      end
-
-      # Removes the given group taking care of removing any referenced target.
+      # Installs the targets which require an installation.
       #
-      # @return [void]
+      # The Pod targets which require an installation (missing, added, or
+      # changed) are installed from scratch for all the targets.
       #
-      def remove_group(group)
-        UI.message"- Removing `#{group}` group" do
-          group.groups.each do |child|
-            remove_group(child)
-          end
-
-          targets = project.targets.select { |target| group.children.include?(target.product_reference) }
-          targets.each do |target|
-            remove_target(target)
-          end
-
-          group.remove_from_project
-        end
-      end
-
-      # Removes the given target removing any reference to it from any other
-      # target.
+      # Only the missing aggregate targets are installed as any reference to
+      # any unrecognized target has already be removed, the references in the
+      # build phases will be synchronized later and the support files will be
+      # regenerated and synchronized in any case.
       #
       # @return [void]
       #
-      def remove_target(target)
-        UI.message"- Removing `#{target.display_name}` target" do
-          target.referrers.each do |ref|
-            if ref.isa == 'PBXTargetDependency'
-              ref.remove_from_project
+      def install_targets
+        pods_to_install.each do |name|
+          UI.message"- Installing `#{name}`" do
+            add_pod(name)
           end
         end
-        target.remove_from_project
 
-          target.product_reference.referrers.each do |ref|
-            if ref.isa == 'PBXBuildFile'
-              ref.remove_from_project
-            end
+        aggregate_targets_to_install.each do |target|
+          UI.message"- Installing `#{target.label}`" do
+            add_aggregate_target(target)
           end
-          target.product_reference.remove_from_project
         end
       end
 
-      # Matches the native targets of the Pods project with the targets
-      # generated by the analyzer.
+      # Generates the support for files for the targets and adds the file
+      # references to them if needed.
       #
       # @return [void]
       #
-      def detect_native_targets
-        native_targets_by_name = project.targets.group_by(&:name)
-        native_targets_to_remove = native_targets_by_name.keys.dup
-        cp_targets = aggregate_targets + all_pod_targets
-        cp_targets.each do |pod_target|
-          native_targets = native_targets_by_name[pod_target.label]
-          if native_targets
-            pod_target.target = native_targets.first
-            native_targets_to_remove.delete(pod_target.label)
-          end
-        end
-
-        native_targets_to_remove.each do |target_name|
-          remove_target(native_targets_by_name[target_name].first)
-        end
-      end
-
-      # @return [void]
-      #
-      def sync_pod_targets
-        pods_to_install.each do |name|
-          add_pod(name)
-        end
-
-        all_pod_targets.each do |target|
+      def sync_support_files
+        targets = all_pod_targets + aggregate_targets
+        targets.reject!(&:skip_installation?)
+        targets.each do |target|
           UI.message"- Generating support files for target `#{target.label}`" do
             gen = SupportFilesGenerator.new(target, sandbox.project)
             gen.generate!
@@ -196,110 +206,105 @@ module Pod
         end
       end
 
-      # Adds and removes aggregate targets to the
+      # Links the aggregate targets with all the dependent pod targets.
+      # Aggregate targets are always created from scratch.
       #
       # @return [void]
       #
-      def sync_aggregate_targets
-        # TODO: Clean up dependencies and linking
-        # TODO: Clean removed targets and their support files
-        # TODO: Fix sorting of targets
-        # TODO: Clean unrecognized targets
-        # TODO: Add integration checks (adding an aggregate target, removing
-        #       one, performing an installation without a project)
-
-        # TODO
-        targets_to_remove = []
-
-        targets_to_install.each do |target|
-          add_aggregate_target(target)
+      def add_missing_aggregate_targets_libraries
+        UI.message"- Populating aggregate targets" do
+          aggregate_targets.each do |aggregate_target|
+            native_target = aggregate_target.target
+            aggregate_target.pod_targets.each do |pod_target|
+              product = pod_target.target.product_reference
+              unless native_target.frameworks_build_phase.files_references.include?(product)
+                native_target.frameworks_build_phase.add_file_reference(product)
               end
-
-        aggregate_targets.each do |target|
-          unless target.target_definition.empty?
-            UI.message"- Generating support files for target `#{target.label}`" do
-              gen = SupportFilesGenerator.new(target, sandbox.project)
-              gen.generate!
             end
           end
         end
       end
 
+      # Synchronizes the dependencies of the targets.
       #
+      # @return [void]
       #
-      def add_aggregate_target(target)
-        UI.message"- Installing `#{target.label}`" do
-          AggregateTargetInstaller.new(sandbox, target).install!
-        end
+      def add_missing_target_dependencies
+        UI.message"- Setting-up target dependencies" do
+          aggregate_targets.each do |aggregate_target|
+            aggregate_target.pod_targets.each do |dep|
+              aggregate_target.target.add_dependency(dep.target)
             end
 
-      #
-      #
-      def add_pod(name)
-        UI.message"- Installing `#{name}`" do
-          pod_targets = all_pod_targets.select { |target| target.pod_name == name }
-
-          remove_group(project.pod_group(name)) if project.pod_group(name)
-          UI.message"- Installing file references" do
-            path = sandbox.pod_dir(name)
-            local = sandbox.local?(name)
-            project.add_pod_group(name, path, local)
-
-            FileReferencesInstaller.new(sandbox, pod_targets).install!
+            aggregate_targets.each do |aggregate_target|
+              aggregate_target.pod_targets.each do |pod_target|
+                dependencies = pod_target.dependencies.map { |dep_name| aggregate_target.pod_targets.find { |target| target.pod_name == dep_name } }
+                dependencies.each do |dep|
+                  pod_target.target.add_dependency(dep.target)
+                end
               end
-
-          pod_targets.each do |pod_target|
-            remove_target(pod_target.target) if pod_target.target
-            UI.message "- Installing target `#{pod_target.name}` #{pod_target.platform}" do
-              PodTargetInstaller.new(sandbox, pod_target).install!
             end
           end
         end
       end
 
 
-      # Sets the dependencies of the targets.
+      private
+
+      # @!group Incremental Editing
+      #-----------------------------------------------------------------------#
+
+      # Matches the native targets of the Pods project with the targets
+      # generated by the analyzer.
       #
       # @return [void]
       #
-      def sync_target_dependencies
-        UI.message"- Setting-up dependencies" do
-          aggregate_targets.each do |aggregate_target|
-            aggregate_target.pod_targets.each do |dep|
-              if dep.target
-                aggregate_target.target.add_dependency(dep.target)
-              else
-                puts "[BUG] #{dep}"
+      def detect_native_targets
+        @native_targets_by_name = project.targets.group_by(&:name)
+        @unrecognized_targets = native_targets_by_name.keys.dup
+        cp_targets = aggregate_targets + all_pod_targets
+        cp_targets.each do |pod_target|
+          native_targets = native_targets_by_name[pod_target.label]
+          if native_targets
+            pod_target.target = native_targets.first
+            @unrecognized_targets.delete(pod_target.label)
           end
         end
       end
 
-          aggregate_targets.each do |aggregate_target|
-            aggregate_target.pod_targets.each do |pod_target|
-              dependencies = pod_target.dependencies.map { |dep_name| aggregate_target.pod_targets.find { |target| target.pod_name == dep_name } }
-              dependencies.each do |dep|
-                pod_target.target.add_dependency(dep.target)
+      # Cleans any unrecognized group in the Pods group and in the support
+      # files group.
+      #
+      # @return [void]
+      #
+      def clean_groups
+        pod_names = all_pod_targets.map(&:pod_name).uniq.sort
+        groups_to_remove = []
+        groups_to_remove << project.pod_groups.reject do |group|
+          pod_names.include?(group.display_name)
         end
+
+        groups_to_remove << project.aggregate_groups.map(&:groups).flatten.reject do |group|
+          pod_names.include?(group.display_name)
         end
+
+        aggregate_names = aggregate_targets.map(&:label).uniq.sort
+        groups_to_remove << project.support_files_group.children.reject do |group|
+          aggregate_names.include?(group.display_name)
         end
+
+        groups_to_remove.flatten.each do |group|
+          remove_group(group)
         end
       end
 
-      # Links the aggregate targets with all the dependent pod targets.
+      # Cleans the unrecognized native targets.
       #
       # @return [void]
       #
-      def sync_aggregate_targets_libraries
-        UI.message"- Populating aggregate targets" do
-          aggregate_targets.each do |aggregate_target|
-            native_target = aggregate_target.target
-            aggregate_target.pod_targets.each do |pod_target|
-              product = pod_target.target.product_reference
-              unless native_target.frameworks_build_phase.files_references.include?(product)
-                native_target.frameworks_build_phase.add_file_reference(product)
-              end
-            end
-          end
+      def clean_native_targets
+        unrecognized_targets.each do |target_name|
+          remove_target(native_targets_by_name[target_name].first)
         end
       end
 
@@ -312,9 +317,9 @@ module Pod
       #
       #
       def should_create_new_project?
-        # TODO
-        incompatible = false
-        incompatible || !sandbox.project_path.exist?
+        # TODO version
+        compatbile_version = '0.24.0'
+        !sandbox.version_at_least?(compatbile_version) || !sandbox.project_path.exist?
       end
 
       #
@@ -343,24 +348,15 @@ module Pod
 
       #
       #
-      def pods_to_remove
-        return [] if new_project
-        # TODO: Unrecognized groups
-        @pods_to_remove ||= (sandbox.state.deleted | sandbox.state.changed).sort
-      end
-
-      def targets_to_install
+      def aggregate_targets_to_install
         aggregate_targets.sort_by(&:name).select do |target|
-          empty = target.target_definition.empty?
-          if new_project
-            !empty
-          else
-            missing = target.target.nil?
-            missing && !empty
-          end
+          target.target.nil? && !target.skip_installation?
         end
       end
 
+      attr_accessor :unrecognized_targets
+      attr_accessor :native_targets_by_name
+
       # Sets the build configuration of the Pods project according the build
       # configurations of the user as detected by the analyzer and other
       # default values.
@@ -382,6 +378,81 @@ module Pod
         end
       end
 
+      # Removes the given group taking care of removing any referenced target.
+      #
+      # @return [void]
+      #
+      def remove_group(group)
+        UI.message"- Removing `#{group}` group" do
+          group.groups.each do |child|
+            remove_group(child)
+          end
+
+          targets = project.targets.select { |target| group.children.include?(target.product_reference) }
+          targets.each do |target|
+            remove_target(target)
+          end
+
+          group.remove_from_project
+        end
+      end
+
+      # Removes the given target removing any reference to it from any other
+      # target.
+      #
+      # @return [void]
+      #
+      def remove_target(target)
+        UI.message"- Removing `#{target.display_name}` target" do
+          target.referrers.each do |ref|
+            if ref.isa == 'PBXTargetDependency'
+              ref.remove_from_project
+            end
+          end
+          target.remove_from_project
+
+          target.product_reference.referrers.each do |ref|
+            if ref.isa == 'PBXBuildFile'
+              ref.remove_from_project
+            end
+          end
+          target.product_reference.remove_from_project
+        end
+      end
+
+      # Installs all the targets of the Pod with the given name. If the Pod
+      # already exists it is removed before.
+      #
+      # @return [void]
+      #
+      def add_pod(name)
+        pod_targets = all_pod_targets.select { |target| target.pod_name == name }
+
+        remove_group(project.pod_group(name)) if project.pod_group(name)
+        UI.message"- Installing file references" do
+          path = sandbox.pod_dir(name)
+          local = sandbox.local?(name)
+          project.add_pod_group(name, path, local)
+
+          FileReferencesInstaller.new(sandbox, pod_targets).install!
+        end
+
+        pod_targets.each do |pod_target|
+          remove_target(pod_target.target) if pod_target.target
+          UI.message "- Installing target `#{pod_target.name}` #{pod_target.platform}" do
+            PodTargetInstaller.new(sandbox, pod_target).install!
+          end
+        end
+      end
+
+      # Installs an aggregate target.
+      #
+      # @return [void]
+      #
+      def add_aggregate_target(target)
+        AggregateTargetInstaller.new(sandbox, target).install!
+      end
+
       #-----------------------------------------------------------------------#
 
     end

lib/cocoapods/installer/pods_project_generator/target_installer.rb

@@ -56,12 +56,9 @@ module Pod
             @native_target.add_build_configuration(bc_name, type)
           end
 
-
           target.target = @native_target
         end
 
-
-
         # @return [PBXNativeTarget] the target generated by the installation
         #         process.
         #

lib/cocoapods/installer/pods_project_generator/target_installer/aggregate_target_installer.rb

@@ -18,5 +18,5 @@ module Pod
         end
       end
     end
-end
+  end
 end

lib/cocoapods/sandbox.rb

@@ -78,6 +78,21 @@ module Pod
       Lockfile.from_file(manifest_path) if manifest_path.exist?
     end
 
+    # Returns whether the version of CocoaPods used to generate the sandbox is
+    # is major than the given version.
+    #
+    # @param  [String]
+    #
+    # @return [Bool]
+    #
+    def version_at_least?(version)
+      if manifest
+        manifest.cocoapods_version >= Version.new(version)
+      else
+        false
+      end
+    end
+
     # @return [Installer::Analyzer::SpecsState] The state of the sandbox
     #         (added, deleted, changed and unchanged pods) as computed by the
     #         analyzer.

lib/cocoapods/target.rb

@@ -35,6 +35,10 @@ module Pod
       label.upcase.gsub(/[^A-Z]/, '_') + '_'
     end
 
+    def skip_installation?
+      false
+    end
+
     # @return [String] A string suitable for debugging.
     #
     def inspect

lib/cocoapods/target/aggregate_target.rb

@@ -15,6 +15,10 @@ module Pod
       @file_accessors = []
     end
 
+    def skip_installation?
+      target_definition.empty?
+    end
+
     # @return [String] the label for the target.
     #
     def label

spec/unit/installer/pods_project_generator_spec.rb

@@ -4,6 +4,10 @@ module Pod
   class Installer
     describe PodsProjectGenerator do
 
+      before do
+        config.sandbox.stubs(:cocoapods_version).returns(Version.new(Pod::VERSION))
+      end
+
       #-----------------------------------------------------------------------#
 
       describe "In general" do
@@ -167,7 +171,30 @@ module Pod
 
       #-----------------------------------------------------------------------#
 
-      describe "#sync_target_dependencies" do
+      describe "#add_missing_aggregate_targets_libraries" do
+
+        before do
+          project = Pod::Project.new(config.sandbox.project_path)
+          @aggregate_native_target = project.new_target(:static_library, 'Pods', :ios)
+          @pod_native_target = project.new_target(:static_library, 'Pods-BananaLib', :ios)
+          pod_target = PodTarget.new([], nil, config.sandbox)
+          pod_target.target = @pod_native_target
+          aggregate_target = AggregateTarget.new(nil, config.sandbox)
+          aggregate_target.pod_targets = [pod_target]
+          aggregate_target.target = @aggregate_native_target
+          @sut = PodsProjectGenerator.new(config.sandbox, [aggregate_target])
+        end
+
+        it "links the aggregate targets to the pod targets" do
+          @sut.send(:add_missing_aggregate_targets_libraries)
+          @aggregate_native_target.frameworks_build_phase.files.map(&:file_ref).should.include?(@pod_native_target.product_reference)
+        end
+
+      end
+
+      #-----------------------------------------------------------------------#
+
+      describe "#add_missing_target_dependencies" do
 
         before do
           project = Pod::Project.new(config.sandbox.project_path)
@@ -188,14 +215,14 @@ module Pod
 
 
         it "sets the pod targets as dependencies of the aggregate target" do
-          @sut.send(:sync_target_dependencies)
+          @sut.send(:add_missing_target_dependencies)
           dependencies = @aggregate_target.target.dependencies
           dependencies.map { |d| d.target.name}.should == ["Pods-BananaLib", "Pods-monkey"]
         end
 
         it "sets the dependencies of the pod targets" do
           @pod_target_1.stubs(:dependencies).returns(['monkey'])
-          @sut.send(:sync_target_dependencies)
+          @sut.send(:add_missing_target_dependencies)
           dependencies = @pod_target_1.target.dependencies
           dependencies.map { |d| d.target.name}.should == ["Pods-monkey"]
         end
@@ -204,29 +231,6 @@ module Pod
 
       #-----------------------------------------------------------------------#
 
-      describe "#sync_aggregate_targets_libraries" do
-
-        before do
-          project = Pod::Project.new(config.sandbox.project_path)
-          @aggregate_native_target = project.new_target(:static_library, 'Pods', :ios)
-          @pod_native_target = project.new_target(:static_library, 'Pods-BananaLib', :ios)
-          pod_target = PodTarget.new([], nil, config.sandbox)
-          pod_target.target = @pod_native_target
-          aggregate_target = AggregateTarget.new(nil, config.sandbox)
-          aggregate_target.pod_targets = [pod_target]
-          aggregate_target.target = @aggregate_native_target
-          @sut = PodsProjectGenerator.new(config.sandbox, [aggregate_target])
-        end
-
-        it "links the aggregate targets to the pod targets" do
-          @sut.send(:sync_aggregate_targets_libraries)
-          @aggregate_native_target.frameworks_build_phase.files.map(&:file_ref).should.include?(@pod_native_target.product_reference)
-        end
-
-      end
-
-      #-----------------------------------------------------------------------#
-
     end
   end
 end

spec/unit/sandbox_spec.rb

@@ -19,6 +19,20 @@ module Pod
         @sandbox.manifest.should == nil
       end
 
+      describe "#version_at_least?" do
+
+      it "returns whether the version of CocoaPods used to generate the sandbox is major to the given one" do
+        manifest = stub(:cocoapods_version => Version.new('1.0'))
+        @sandbox.stubs(:manifest).returns(manifest)
+        @sandbox.version_at_least?('1.0.0').should.be.true
+      end
+
+      it "returns false if the manifest is not available" do
+        @sandbox.version_at_least?('0.0.1').should.be.false
+      end
+
+      end
+
       it "returns the project" do
         @sandbox.project.should == nil
       end