cocoapods 1.7.5 → 1.8.0.beta.1

data/lib/cocoapods/installer/installation_options.rb

@@ -181,6 +181,10 @@ module Pod
       # since the previous installation.
       #
       option :incremental_installation, false
+
+      # Whether to skip generating the `Pods.xcodeproj` and perform only dependency resolution and downloading.
+      #
+      option :skip_pods_project_generation, false
     end
   end
 end

data/lib/cocoapods/installer/pod_source_installer.rb

@@ -14,6 +14,11 @@ module Pod
       #
       attr_reader :sandbox
 
+      # @return [Podfile] the podfile that should be integrated with the user
+      #         projects.
+      #
+      attr_reader :podfile
+
       # @return [Hash{Symbol=>Array}] The specifications that need to be
       #         installed grouped by platform.
       #
@@ -27,11 +32,13 @@ module Pod
       # Initialize a new instance
       #
       # @param [Sandbox] sandbox @see #sandbox
+      # @param [Podfile] podfile @see #podfile
       # @param [Hash{Symbol=>Array}] specs_by_platform @see #specs_by_platform
       # @param [Boolean] can_cache @see #can_cache
       #
-      def initialize(sandbox, specs_by_platform, can_cache: true)
+      def initialize(sandbox, podfile, specs_by_platform, can_cache: true)
         @sandbox = sandbox
+        @podfile = podfile
         @specs_by_platform = specs_by_platform
         @can_cache = can_cache
       end
@@ -61,6 +68,7 @@ module Pod
       def install!
         download_source unless predownloaded? || local?
         PodSourcePreparer.new(root_spec, root).prepare! if local?
+        sandbox.remove_local_podspec(name) unless predownloaded? || local? || external?
       end
 
       # Cleans the installations if appropriate.
@@ -191,6 +199,14 @@ module Pod
         sandbox.local?(root_spec.name)
       end
 
+      # @return [Boolean] whether the pod uses an external source (e.g. :podspec) in the
+      #         resolution process to retrieve its podspec.
+      #
+      def external?
+        @dependencies ||= podfile.dependencies.select(&:external?).map(&:name)
+        @dependencies.include?(root_spec.name)
+      end
+
       def released?
         !local? && !predownloaded? && sandbox.specification(root_spec.name) != root_spec
       end

data/lib/cocoapods/installer/podfile_validator.rb

@@ -122,15 +122,35 @@ module Pod
       end
 
       # Verifies that no dependencies in the Podfile will end up not being built
-      # at all. In other words, all dependencies _must_ belong to a non-abstract
+      # at all. In other words, all dependencies should belong to a non-abstract
       # target, or be inherited by a target where `inheritance == complete`.
       #
       def validate_no_abstract_only_pods!
-        all_dependencies = @podfile_dependency_cache.podfile_dependencies
-        concrete_dependencies = @podfile_dependency_cache.target_definition_list.reject(&:abstract?).flat_map { |td| @podfile_dependency_cache.target_definition_dependencies(td) }
-        abstract_only_dependencies = all_dependencies - concrete_dependencies
-        abstract_only_dependencies.each do |dep|
-          add_error "The dependency `#{dep}` is not used in any concrete target."
+        @podfile_dependency_cache.target_definition_list.each do |target_definition|
+          dependencies = @podfile_dependency_cache.target_definition_dependencies(target_definition)
+          next if dependencies.empty?
+          next unless target_definition.abstract?
+
+          children = target_definition.recursive_children
+          next if children.any? { |child_target_definition| target_definition_inherits?(:parent => target_definition, :child => child_target_definition) }
+
+          add_warning "The abstract target #{target_definition.name} is not inherited by a concrete target, " \
+            "so the following dependencies won't make it into any targets in your project:" \
+            "\n    - #{dependencies.map(&:to_s).sort.join("\n    - ")}"
+
+          next if target_definition.platform
+
+          add_error "The abstract target #{target_definition.name} must specify a platform since its dependencies are not inherited by a concrete target."
+        end
+      end
+
+      def target_definition_inherits?(parent: nil, child: nil)
+        if parent == child
+          true
+        elsif child.exclusive?
+          false
+        else
+          target_definition_inherits?(:parent => parent, :child => child.parent)
         end
       end
 

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

@@ -75,15 +75,19 @@ module Pod
             return full_install_results
           end
 
+          if project_names_changed?(pod_targets, cache)
+            UI.message 'Ignoring project cache due to project name changes.'
+            return full_install_results
+          end
+
           pod_targets_to_generate = Set[]
           aggregate_targets_to_generate = Set[]
-          added_targets, removed_targets = compute_added_and_removed_targets(target_by_label,
-                                                                             cache_key_by_target_label.keys,
-                                                                             cache.cache_key_by_target_label.keys)
+          added_targets = compute_added_targets(target_by_label, cache_key_by_target_label.keys, cache.cache_key_by_target_label.keys)
           added_pod_targets, added_aggregate_targets = added_targets.partition { |target| target.is_a?(PodTarget) }
-          removed_aggregate_targets = removed_targets.select { |target| target.is_a?(AggregateTarget) }
           pod_targets_to_generate.merge(added_pod_targets)
-          aggregate_targets_to_generate.merge(added_aggregate_targets + removed_aggregate_targets)
+          aggregate_targets_to_generate.merge(added_aggregate_targets)
+
+          removed_aggregate_target_labels = compute_removed_targets(cache_key_by_target_label.keys, cache.cache_key_by_target_label.keys)
 
           changed_targets = compute_changed_targets_from_cache(cache_key_by_target_label, target_by_label, cache)
           changed_pod_targets, changed_aggregate_targets = changed_targets.partition { |target| target.is_a?(PodTarget) }
@@ -95,23 +99,21 @@ module Pod
           pod_targets_to_generate.merge(dirty_pod_targets)
           aggregate_targets_to_generate.merge(dirty_aggregate_targets)
 
-          # Since multi xcodeproj will group targets by PodTarget#pod_name into individual projects, we
-          # need to append these "sibling" targets to the list of targets we need to generate before finalizing the total list,
+          # Since multi xcodeproj will group targets by PodTarget#project_name into individual projects, we need to
+          # append these "sibling" targets to the list of targets we need to generate before finalizing the total list,
           # otherwise we will end up with missing targets.
           #
           sibling_pod_targets = compute_sibling_pod_targets(pod_targets, pod_targets_to_generate)
           pod_targets_to_generate.merge(sibling_pod_targets)
 
-          # We either return the full list of aggregate targets or none since the aggregate targets go into the Pods.xcodeproj
-          # and so we need to regenerate all aggregate targets when regenerating Pods.xcodeproj.
+          # We either return the full list of aggregate targets or none since the aggregate targets go into the
+          # Pods.xcodeproj and so we need to regenerate all aggregate targets when regenerating Pods.xcodeproj.
+          total_aggregate_targets_to_generate = unless aggregate_targets_to_generate.empty? && removed_aggregate_target_labels.empty?
+                                                  aggregate_targets
+                                                end
 
-          total_aggregate_targets_to_generate =
-            unless aggregate_targets_to_generate.empty?
-              aggregate_targets
-            end
-
-          ProjectCacheAnalysisResult.new(pod_targets_to_generate.to_a, total_aggregate_targets_to_generate, cache_key_by_target_label,
-                                         build_configurations, project_object_version)
+          ProjectCacheAnalysisResult.new(pod_targets_to_generate.to_a, total_aggregate_targets_to_generate,
+                                         cache_key_by_target_label, build_configurations, project_object_version)
         end
 
         private
@@ -122,23 +124,24 @@ module Pod
             when PodTarget
               local = sandbox.local?(target.pod_name)
               checkout_options = sandbox.checkout_sources[target.pod_name]
-              [label, TargetCacheKey.from_pod_target(target, :is_local_pod => local, :checkout_options => checkout_options)]
+              [label, TargetCacheKey.from_pod_target(sandbox, target, :is_local_pod => local,
+                                                                      :checkout_options => checkout_options)]
             when AggregateTarget
-              [label, TargetCacheKey.from_aggregate_target(target)]
+              [label, TargetCacheKey.from_aggregate_target(sandbox, target)]
             else
               raise "[BUG] Unknown target type #{target}"
             end
           end]
         end
 
-        def compute_added_and_removed_targets(target_by_label, target_labels, cached_target_labels)
-          added_targets = (target_labels - cached_target_labels).map do |label|
+        def compute_added_targets(target_by_label, target_labels, cached_target_labels)
+          (target_labels - cached_target_labels).map do |label|
             target_by_label[label]
           end
-          removed_targets = (cached_target_labels - target_labels).map do |label|
-            target_by_label[label]
-          end
-          [added_targets, removed_targets]
+        end
+
+        def compute_removed_targets(target_labels, cached_target_labels)
+          cached_target_labels - target_labels
         end
 
         def compute_changed_targets_from_cache(cache_key_by_target_label, target_by_label, cache)
@@ -155,7 +158,7 @@ module Pod
             support_files_dir_exists = File.exist? target.support_files_dir
             xcodeproj_exists = case target
                                when PodTarget
-                                 File.exist? sandbox.pod_target_project_path(target.pod_name)
+                                 File.exist? sandbox.pod_target_project_path(target.project_name)
                                when AggregateTarget
                                  File.exist? sandbox.project_path
                                else
@@ -166,8 +169,15 @@ module Pod
         end
 
         def compute_sibling_pod_targets(pod_targets, pod_targets_to_generate)
-          pod_targets_by_name = pod_targets.group_by(&:pod_name)
-          pod_targets_to_generate.flat_map { |t| pod_targets_by_name[t.pod_name] }
+          pod_targets_by_project_name = pod_targets.group_by(&:project_name)
+          pod_targets_to_generate.flat_map { |t| pod_targets_by_project_name[t.project_name] }
+        end
+
+        def project_names_changed?(pod_targets, cache)
+          pod_targets.any? do |pod_target|
+            next unless (target_cache_key = cache.cache_key_by_target_label[pod_target.label])
+            target_cache_key.project_name != pod_target.project_name
+          end
         end
       end
     end

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

@@ -35,7 +35,7 @@ module Pod
         #        The path of the project cache to save.
         #
         def save_as(path)
-          open(path, 'w') { |f| f.puts version.to_s }
+          Sandbox.update_changed_file(path, version.to_s)
         end
       end
     end

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

@@ -47,15 +47,15 @@ module Pod
 
         def save_as(path)
           Pathname(path).dirname.mkpath
-          path.open('w') { |f| f.puts YAMLHelper.convert(to_hash) }
+          Sandbox.update_changed_file(path, YAMLHelper.convert(to_hash))
         end
 
-        def self.from_file(path)
+        def self.from_file(sandbox, path)
           return ProjectInstallationCache.new unless File.exist?(path)
           contents = YAMLHelper.load_file(path)
           cache_keys = contents.fetch('CACHE_KEYS', {})
           cache_key_by_target_label = Hash[cache_keys.map do |name, key_hash|
-            [name, TargetCacheKey.from_cache_hash(key_hash)]
+            [name, TargetCacheKey.from_cache_hash(sandbox, key_hash)]
           end]
           project_object_version = contents['OBJECT_VERSION']
           build_configurations = contents['BUILD_CONFIGURATIONS']

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

@@ -6,6 +6,10 @@ module Pod
       class ProjectMetadataCache
         require 'cocoapods/installer/project_cache/target_metadata.rb'
 
+        # @return [Sandbox] The sandbox where the Pods should be installed.
+        #
+        attr_reader :sandbox
+
         # @return [Hash{String => TargetMetadata}]
         #         Hash of string by target metadata.
         #
@@ -13,9 +17,11 @@ module Pod
 
         # Initialize a new instance.
         #
+        # @param [Sandbox] sandbox see #sandbox
         # @param [Hash{String => TargetMetadata}] target_label_by_metadata @see #target_label_by_metadata
         #
-        def initialize(target_label_by_metadata = {})
+        def initialize(sandbox, target_label_by_metadata = {})
+          @sandbox = sandbox
           @target_label_by_metadata = target_label_by_metadata
         end
 
@@ -32,7 +38,7 @@ module Pod
         # @return [void]
         #
         def save_as(path)
-          path.open('w') { |f| f.puts YAMLHelper.convert_hash(to_hash, nil) }
+          Sandbox.update_changed_file(path, YAMLHelper.convert_hash(to_hash, nil))
         end
 
         # Updates the metadata cache based on installation results.
@@ -47,15 +53,15 @@ module Pod
           installation_results = pod_target_installation_results.values + aggregate_target_installation_results.values
           installation_results.each do |installation_result|
             native_target = installation_result.native_target
-            target_label_by_metadata[native_target.name] = TargetMetadata.from_native_target(native_target)
+            target_label_by_metadata[native_target.name] = TargetMetadata.from_native_target(sandbox, native_target)
           end
         end
 
-        def self.from_file(path)
-          return ProjectMetadataCache.new unless File.exist?(path)
+        def self.from_file(sandbox, path)
+          return ProjectMetadataCache.new(sandbox) unless File.exist?(path)
           contents = YAMLHelper.load_file(path)
           target_by_label_metadata = Hash[contents.map { |target_label, hash| [target_label, TargetMetadata.from_hash(hash)] }]
-          ProjectMetadataCache.new(target_by_label_metadata)
+          ProjectMetadataCache.new(sandbox, target_by_label_metadata)
         end
       end
     end

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

@@ -8,6 +8,10 @@ module Pod
         require 'cocoapods/target/aggregate_target.rb'
         require 'digest'
 
+        # @return [Sandbox] The sandbox where the Pods should be installed.
+        #
+        attr_reader :sandbox
+
         # @return [Symbol]
         #         The type of target. Either aggregate or pod target.
         #
@@ -20,10 +24,12 @@ module Pod
 
         # Initialize a new instance.
         #
+        # @param [Sandbox] sandbox see #sandbox
         # @param [Symbol] type @see #type
         # @param [Hash{String => Object}] key_hash @see #key_hash
         #
-        def initialize(type, key_hash)
+        def initialize(sandbox, type, key_hash)
+          @sandbox = sandbox
           @type = type
           @key_hash = key_hash
         end
@@ -46,6 +52,7 @@ module Pod
               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']
+              return :project if other.key_hash['PROJECT_NAME'] != key_hash['PROJECT_NAME']
             end
 
             this_build_settings = key_hash['BUILD_SETTINGS_CHECKSUM']
@@ -64,14 +71,23 @@ module Pod
           key_hash
         end
 
+        # @return [String]
+        #         The name of the project the target belongs to.
+        #
+        def project_name
+          key_hash['PROJECT_NAME']
+        end
+
         # Creates a TargetCacheKey instance from the given hash.
         #
+        # @param [Sandbox] sandbox The sandbox to use to construct a TargetCacheKey object.
+        #
         # @param [Hash{String => Object}] key_hash
         #        The hash used to construct a TargetCacheKey object.
         #
         # @return [TargetCacheKey]
         #
-        def self.from_cache_hash(key_hash)
+        def self.from_cache_hash(sandbox, key_hash)
           cache_hash = key_hash.dup
           if files = cache_hash['FILES']
             cache_hash['FILES'] = files.sort_by(&:downcase)
@@ -80,11 +96,13 @@ module Pod
             cache_hash['SPECS'] = specs.sort_by(&:downcase)
           end
           type = cache_hash['CHECKSUM'] ? :pod_target : :aggregate
-          TargetCacheKey.new(type, cache_hash)
+          TargetCacheKey.new(sandbox, type, cache_hash)
         end
 
         # Constructs a TargetCacheKey instance from a PodTarget.
         #
+        # @param [Sandbox] sandbox The sandbox to use to construct a TargetCacheKey object.
+        #
         # @param [PodTarget] pod_target
         #        The pod target used to construct a TargetCacheKey object.
         #
@@ -96,7 +114,7 @@ module Pod
         #
         # @return [TargetCacheKey]
         #
-        def self.from_pod_target(pod_target, is_local_pod: false, checkout_options: nil)
+        def self.from_pod_target(sandbox, 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|
@@ -110,26 +128,32 @@ module Pod
             'CHECKSUM' => pod_target.root_spec.checksum,
             'SPECS' => pod_target.specs.map(&:to_s).sort_by(&:downcase),
             'BUILD_SETTINGS_CHECKSUM' => build_settings,
+            'PROJECT_NAME' => pod_target.project_name,
           }
-          contents['FILES'] = pod_target.all_files.sort_by(&:downcase) if is_local_pod
+          if is_local_pod
+            relative_file_paths = pod_target.all_files.map { |f| Pathname.new(f).relative_path_from(sandbox.root).to_s }
+            contents['FILES'] = relative_file_paths.sort_by(&:downcase)
+          end
           contents['CHECKOUT_OPTIONS'] = checkout_options if checkout_options
-          TargetCacheKey.new(:pod_target, contents)
+          TargetCacheKey.new(sandbox, :pod_target, contents)
         end
 
         # Construct a TargetCacheKey instance from an AggregateTarget.
         #
+        # @param [Sandbox] sandbox The sandbox to use to construct a TargetCacheKey object.
+        #
         # @param [AggregateTarget] aggregate_target
         #        The aggregate target used to construct a TargetCacheKey object.
         #
         # @return [TargetCacheKey]
         #
-        def self.from_aggregate_target(aggregate_target)
+        def self.from_aggregate_target(sandbox, 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)
+          TargetCacheKey.new(sandbox, :aggregate, 'BUILD_SETTINGS_CHECKSUM' => build_settings)
         end
       end
     end

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

@@ -56,13 +56,17 @@ module Pod
 
         # Constructs a TargetMetadata instance from a native target.
         #
+        # @param [Sandbox] sandbox
+        #        The sandbox used for this installation.
+        #
         # @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)
+        def self.from_native_target(sandbox, native_target)
+          TargetMetadata.new(native_target.name, native_target.uuid,
+                             native_target.project.path.relative_path_from(sandbox.root).to_s)
         end
       end
     end

data/lib/cocoapods/installer/sandbox_dir_cleaner.rb

@@ -62,6 +62,14 @@ module Pod
 
           removed_sandbox_private_headers = sandbox_private_headers(pod_targets) - sandbox_private_headers_to_install
           removed_sandbox_private_headers.each { |path| remove_dir(path) }
+
+          project_dir_names_to_install = pod_targets.map do |pod_target|
+            sandbox.pod_target_project_path(pod_target.project_name)
+          end
+          project_dir_names = sandbox_project_dir_names - [sandbox.project_path]
+
+          removed_project_dir_names = project_dir_names - project_dir_names_to_install
+          removed_project_dir_names.each { |dir| remove_dir(dir) }
         end
       end
 
@@ -75,6 +83,10 @@ module Pod
         pod_targets.flat_map { |pod_target| child_directories_of(pod_target.build_headers.root) }.uniq
       end
 
+      def sandbox_project_dir_names
+        child_directories_of(sandbox.root).select { |d| d.extname == '.xcodeproj' }
+      end
+
       def sandbox_public_headers
         child_directories_of(sandbox.public_headers.root)
       end