cocoapods 1.6.2 → 1.7.0.beta.1

data/lib/cocoapods/installer/pod_source_installer.rb

@@ -65,6 +65,11 @@ module Pod
 
       # Cleans the installations if appropriate.
       #
+      # Cleaning the installation will remove any files that are not used during the build process, based on
+      # the podspec and platforms of the target that the pod is integrated into.
+      #
+      # @see {#clean_installation}
+      #
       # @return [void]
       #
       def clean!
@@ -137,6 +142,10 @@ module Pod
         )
       end
 
+      #-----------------------------------------------------------------------#
+
+      private
+
       # Removes all the files not needed for the installation according to the
       # specs by platform.
       #
@@ -147,10 +156,6 @@ module Pod
         cleaner.clean!
       end
 
-      #-----------------------------------------------------------------------#
-
-      private
-
       # @!group Convenience methods.
 
       # @return [Array<Specifications>] the specification of the Pod used in

data/lib/cocoapods/installer/podfile_validator.rb

@@ -36,6 +36,7 @@ module Pod
       # Errors are added to the errors array
       #
       def validate
+        validate_installation_options
         validate_pod_directives
         validate_no_abstract_only_pods!
         validate_dependencies_are_present!
@@ -71,6 +72,14 @@ module Pod
         warnings << warning
       end
 
+      def validate_installation_options
+        installation_options = podfile.installation_options
+
+        # Validate `incremental_installation` depends on `generate_multiple_pod_projects`
+        invalid = installation_options.incremental_installation? && installation_options.incremental_installation != installation_options.generate_multiple_pod_projects
+        add_error 'The installation option `incremental_installation` requires the option `generate_multiple_pod_projects` to also be enabled.' if invalid
+      end
+
       def validate_pod_directives
         @podfile_dependency_cache.podfile_dependencies.each do |dependency|
           validate_conflicting_external_sources!(dependency)

data/lib/cocoapods/installer/post_install_hooks_context.rb

@@ -40,6 +40,9 @@ module Pod
       # @param  [Sandbox] sandbox
       #         The sandbox
       #
+      # @param  [Project] pods_project
+      #         The pods project.
+      #
       # @param  [Array<AggregateTarget>] aggregate_targets
       #         The aggregate targets, which will been presented by an adequate
       #         {UmbrellaTargetDescription} in the generated context.
@@ -47,7 +50,7 @@ module Pod
       # @return [HooksContext] Convenience class method to generate the
       #         static context.
       #
-      def self.generate(sandbox, aggregate_targets)
+      def self.generate(sandbox, pods_project, aggregate_targets)
         umbrella_targets_descriptions = aggregate_targets.map do |umbrella|
           user_project = umbrella.user_project
           user_targets = umbrella.user_targets
@@ -58,7 +61,7 @@ module Pod
           UmbrellaTargetDescription.new(user_project, user_targets, specs, platform_name, platform_deployment_target, cocoapods_target_label)
         end
 
-        new(sandbox, sandbox.root.to_s, sandbox.project, umbrella_targets_descriptions)
+        new(sandbox, sandbox.root.to_s, pods_project, umbrella_targets_descriptions)
       end
 
       # Pure data class which describes an umbrella target.

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

@@ -0,0 +1,11 @@
+module Pod
+  class Installer
+    module ProjectCache
+      autoload :ProjectCacheAnalyzer,       'cocoapods/installer/project_cache/project_cache_analyzer'
+      autoload :ProjectInstallationCache,   'cocoapods/installer/project_cache/project_installation_cache'
+      autoload :ProjectMetadataCache,       'cocoapods/installer/project_cache/project_metadata_cache'
+      autoload :ProjectCacheAnalysisResult, 'cocoapods/installer/project_cache/project_cache_analysis_result'
+      autoload :ProjectCacheVersion,        'cocoapods/installer/project_cache/project_cache_version'
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Pod
+  class Installer
+    module ProjectCache
+      # The result object from analyzing the project cache.
+      #
+      class ProjectCacheAnalysisResult
+        # @return [Array<PodTarget>]
+        #         The list of pod targets that need to be regenerated.
+        #
+        attr_reader :pod_targets_to_generate
+
+        # @return [Array<AggregateTarget>]
+        #         The list of aggregate targets that need to be regenerated. This can be nil if we don't want to
+        #         generate ANY aggregate targets since we still want to be able to generate an empty list of aggregate
+        #         targets.
+        #
+        attr_reader :aggregate_targets_to_generate
+
+        # @return [Hash{String => TargetCacheKey}]
+        #         Updated hash of target cache key by target label for all targets.
+        #
+        attr_reader :cache_key_by_target_label
+
+        # @return [Hash{String => Symbol}]
+        #         The build configurations to install with each target.
+        #
+        attr_reader :build_configurations
+
+        # @return [String]
+        #         The project object version to install with each target.
+        #
+        attr_reader :project_object_version
+
+        # Initialize a new instance.
+        #
+        # @param [Array<PodTarget>] pod_targets_to_generate @see #pod_targets_to_generate
+        # @param [Array<AggregateTarget] aggregate_targets_to_generate @see #aggregate_targets_to_generate
+        # @param [Hash{String => TargetCacheKey}] cache_key_by_target_label @see #cache_key_by_target_label
+        # @param [Hash{String => Symbol}] build_configurations @see #build_configurations
+        # @param [String] project_object_version @see #project_object_version
+        #
+        def initialize(pod_targets_to_generate, aggregate_targets_to_generate, cache_key_by_target_label,
+                       build_configurations, project_object_version)
+          @pod_targets_to_generate = pod_targets_to_generate
+          @aggregate_targets_to_generate = aggregate_targets_to_generate
+          @cache_key_by_target_label = cache_key_by_target_label
+          @build_configurations = build_configurations
+          @project_object_version = project_object_version
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+module Pod
+  class Installer
+    module ProjectCache
+      # Analyzes the project cache and computes which pod targets need to be generated.
+      #
+      class ProjectCacheAnalyzer
+        require 'cocoapods/installer/project_cache/project_cache_analysis_result'
+
+        # @return [Sandbox] Project sandbox.
+        #
+        attr_reader :sandbox
+
+        # @return [ProjectInstallationCache] The cache of targets that were previously installed.
+        #
+        attr_reader :cache
+
+        # @return [Hash{String => Symbol}] The hash of user build configurations.
+        #
+        attr_reader :build_configurations
+
+        # @return [String] The object version from the user project.
+        #
+        attr_reader :project_object_version
+
+        # @return [Array<PodTarget>] The list of pod targets.
+        #
+        attr_reader :pod_targets
+
+        # @return [Array<AggregateTarget>] The list of aggregate targets.
+        #
+        attr_reader :aggregate_targets
+
+        # @return [Bool] Flag indicating if we want to ignore the cache and force a clean installation.
+        #
+        attr_reader :clean_install
+
+        # Initialize a new instance.
+        #
+        # @param [Sandbox] sandbox @see #sandbox
+        # @param [ProjectInstallationCache] cache @see #cache
+        # @param [Hash{String => Symbol}] build_configurations @see #build_configurations
+        # @param [String] project_object_version @see #project_object_version
+        # @param [Array<PodTarget>] pod_targets @see #pod_targets
+        # @param [Array<AggregateTarget>] aggregate_targets @see #aggregate_targets
+        # @param [Bool] clean_install @see #clean_install
+        #
+        def initialize(sandbox, cache, build_configurations, project_object_version, pod_targets, aggregate_targets,
+                       clean_install: false)
+          @sandbox = sandbox
+          @cache = cache
+          @build_configurations = build_configurations
+          @pod_targets = pod_targets
+          @aggregate_targets = aggregate_targets
+          @project_object_version = project_object_version
+          @clean_install = clean_install
+        end
+
+        # @return [ProjectCacheAnalysisResult]
+        #         Compares all targets stored against the cache and computes which targets need to be regenerated.
+        #
+        def analyze
+          target_by_label = Hash[(pod_targets + aggregate_targets).map { |target| [target.label, target] }]
+          cache_key_by_target_label = create_cache_key_mappings(target_by_label)
+
+          full_install_results = ProjectCacheAnalysisResult.new(pod_targets, aggregate_targets, cache_key_by_target_label,
+                                                                build_configurations, project_object_version)
+          if clean_install
+            UI.message 'Ignoring project cache from the provided `--clean-install` flag.'
+            return full_install_results
+          end
+
+          # Bail out early since these properties affect all targets and their associate projects.
+          if cache.build_configurations != build_configurations || cache.project_object_version != project_object_version
+            UI.message 'Ignoring project cache due to project configuration changes.'
+            return full_install_results
+          end
+
+          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_pod_targets, added_aggregate_targets = added_targets.partition { |target| target.is_a?(PodTarget) }
+          removed_aggregate_targets = removed_targets.select { |target| target.is_a?(AggregateTarget) }
+
+          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) }
+
+          dirty_targets = compute_dirty_targets(pod_targets + aggregate_targets)
+          dirty_pod_targets, dirty_aggregate_targets = dirty_targets.partition { |target| target.is_a?(PodTarget) }
+
+          pod_targets_to_generate = (changed_pod_targets + added_pod_targets + dirty_pod_targets).uniq
+
+          # 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.
+          aggregate_target_to_generate =
+            unless (changed_aggregate_targets + added_aggregate_targets + removed_aggregate_targets + dirty_aggregate_targets).empty?
+              aggregate_targets
+            end
+
+          ProjectCacheAnalysisResult.new(pod_targets_to_generate, aggregate_target_to_generate, cache_key_by_target_label,
+                                         build_configurations, project_object_version)
+        end
+
+        private
+
+        def create_cache_key_mappings(target_by_label)
+          Hash[target_by_label.map do |label, target|
+            case target
+            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)]
+            when AggregateTarget
+              [label, TargetCacheKey.from_aggregate_target(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|
+            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_changed_targets_from_cache(cache_key_by_target_label, target_by_label, cache)
+          cache_key_by_target_label.each_with_object([]) do |(label, cache_key), changed_targets|
+            next unless cache.cache_key_by_target_label[label]
+            if cache_key.key_difference(cache.cache_key_by_target_label[label]) == :project
+              changed_targets << target_by_label[label]
+            end
+          end
+        end
+
+        def compute_dirty_targets(targets)
+          targets.reject do |target|
+            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)
+                               when AggregateTarget
+                                 File.exist? sandbox.project_path
+                               else
+                                 raise "[BUG] Unknown target type #{target}"
+                               end
+            support_files_dir_exists && xcodeproj_exists
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Pod
+  class Installer
+    module ProjectCache
+      # Object that stores, loads, and holds the version of the project cache.
+      #
+      class ProjectCacheVersion
+        # @return [Version] The version of the project cache.
+        #
+        attr_reader :version
+
+        # Initialize a new instance.
+        #
+        # @param [Version] version @see #version
+        #
+        def initialize(version = Version.create('0'))
+          @version = version
+        end
+
+        # Constructs a ProjectCacheVersion from a file.
+        #
+        # @param [String] path
+        #        The path of the project cache
+        #
+        # @return [ProjectCacheVersion]
+        #
+        def self.from_file(path)
+          return ProjectCacheVersion.new unless File.exist?(path)
+          cached_version = Version.create(File.read(path))
+          ProjectCacheVersion.new(cached_version)
+        end
+
+        # @return [void]
+        #
+        # @param [String] path
+        #        The path of the project cache to save.
+        #
+        def save_as(path)
+          open(path, 'w') { |f| f.puts version.to_s }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module Pod
+  class Installer
+    module ProjectCache
+      # Represents the cache stored at Pods/.project/installation_cache
+      #
+      class ProjectInstallationCache
+        require 'cocoapods/installer/project_cache/target_cache_key'
+
+        # @return [Hash{String => TargetCacheKey}]
+        #         Stored hash of target cache key objects for every pod target.
+        #
+        attr_reader :cache_key_by_target_label
+
+        # @return [Hash{String => Symbol}]
+        #         Build configurations stored in the cache.
+        #
+        attr_reader :build_configurations
+
+        # @return [String]
+        #         Project object stored in the cache.
+        #
+        attr_reader :project_object_version
+
+        # Initializes a new instance.
+        #
+        # @param [Hash{String => TargetCacheKey}] cache_key_by_target_label @see #cache_key_by_target_label
+        # @param [Hash{String => Symbol}] build_configurations @see #build_configurations
+        # @param [String] project_object_version @see #project_object_version
+        #
+        def initialize(cache_key_by_target_label = {}, build_configurations = nil, project_object_version = nil)
+          @cache_key_by_target_label = cache_key_by_target_label
+          @build_configurations = build_configurations
+          @project_object_version = project_object_version
+        end
+
+        def update_cache_key_by_target_label!(cache_key_by_target_label)
+          @cache_key_by_target_label = cache_key_by_target_label
+        end
+
+        def update_build_configurations!(build_configurations)
+          @build_configurations = build_configurations
+        end
+
+        def update_project_object_version!(project_object_version)
+          @project_object_version = project_object_version
+        end
+
+        def save_as(path)
+          Pathname(path).dirname.mkpath
+          path.open('w') { |f| f.puts YAMLHelper.convert(to_hash) }
+        end
+
+        def self.from_file(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)]
+          end]
+          project_object_version = contents['OBJECT_VERSION']
+          build_configurations = contents['BUILD_CONFIGURATIONS']
+          ProjectInstallationCache.new(cache_key_by_target_label, build_configurations, project_object_version)
+        end
+
+        def to_hash
+          cache_key_contents = Hash[cache_key_by_target_label.map do |label, key|
+            [label, key.to_h]
+          end]
+          contents = { 'CACHE_KEYS' => cache_key_contents }
+          contents['BUILD_CONFIGURATIONS'] = build_configurations if build_configurations
+          contents['OBJECT_VERSION'] = project_object_version if project_object_version
+          contents
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Pod
+  class Installer
+    module ProjectCache
+      # Represents the metadata cache
+      #
+      class ProjectMetadataCache
+        require 'cocoapods/installer/project_cache/target_metadata.rb'
+
+        # @return [Hash{String => TargetMetadata}]
+        #         Hash of string by target metadata.
+        #
+        attr_reader :target_label_by_metadata
+
+        # Initialize a new instance.
+        #
+        # @param [Hash{String => TargetMetadata}] target_label_by_metadata @see #target_label_by_metadata
+        #
+        def initialize(target_label_by_metadata = {})
+          @target_label_by_metadata = target_label_by_metadata
+        end
+
+        def to_hash
+          Hash[target_label_by_metadata.map do |target_label, metdata|
+            [target_label, metdata.to_hash]
+          end]
+        end
+
+        # Rewrites the entire cache to the given path.
+        #
+        # @param [String] path
+        #
+        # @return [void]
+        #
+        def save_as(path)
+          path.open('w') { |f| f.puts YAMLHelper.convert_hash(to_hash, nil) }
+        end
+
+        # Updates the metadata cache based on installation results.
+        #
+        # @param [Hash{String => TargetInstallationResult}] pod_target_installation_results
+        #        The installation results for pod targets installed.
+        #
+        # @param [Hash{String => TargetInstallationResult}] aggregate_target_installation_results
+        #        The installation results for aggregate targets installed.
+        #
+        def update_metadata!(pod_target_installation_results, aggregate_target_installation_results)
+          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)
+          end
+        end
+
+        def self.from_file(path)
+          return ProjectMetadataCache.new 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)
+        end
+      end
+    end
+  end
+end