cocoapods-tt 0.0.1

data/lib/cocoapods-tt/native/installer/podfile_validator.rb

@@ -0,0 +1,168 @@
+module Pod
+  class Installer
+    # Validate the podfile before installing to catch errors and
+    # problems
+    #
+    class PodfileValidator
+      # @return [Podfile] The podfile being validated
+      #
+      attr_reader :podfile
+
+      # @return [Array<String>] any errors that have occurred during the validation
+      #
+      attr_reader :errors
+
+      # @return [Array<String>] any warnings that have occurred during the validation
+      #
+      attr_reader :warnings
+
+      # Initialize a new instance
+      #
+      # @param [Podfile] podfile
+      #        The podfile to validate
+      #
+      # @param [Analyzer::PodfileDependencyCache] podfile_dependency_cache
+      #        An (optional) cache of all the dependencies in the podfile
+      #
+      def initialize(podfile, podfile_dependency_cache = Analyzer::PodfileDependencyCache.from_podfile(podfile))
+        @podfile = podfile
+        @podfile_dependency_cache = podfile_dependency_cache
+        @errors = []
+        @warnings = []
+        @validated = false
+      end
+
+      # Validate the podfile
+      # Errors are added to the errors array
+      #
+      def validate
+        validate_installation_options
+        validate_pod_directives
+        validate_no_abstract_only_pods!
+        validate_dependencies_are_present!
+        validate_no_duplicate_targets!
+
+        @validated = true
+      end
+
+      # Wether the podfile is valid is not
+      # NOTE: Will execute `validate` if the podfile
+      # has not yet been validated
+      #
+      def valid?
+        validate unless @validated
+
+        @validated && errors.empty?
+      end
+
+      # A message describing any errors in the
+      # validation
+      #
+      def message
+        errors.join("\n")
+      end
+
+      private
+
+      def add_error(error)
+        errors << error
+      end
+
+      def add_warning(warning)
+        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)
+        end
+      end
+
+      def validate_conflicting_external_sources!(dependency)
+        external_source = dependency.external_source
+        return false if external_source.nil?
+
+        available_downloaders = Downloader.downloader_class_by_key.keys
+        specified_downloaders = external_source.select { |key| available_downloaders.include?(key) }
+        if specified_downloaders.size > 1
+          add_error "The dependency `#{dependency.name}` specifies more than one download strategy(#{specified_downloaders.keys.join(',')})." \
+            'Only one is allowed'
+        end
+
+        pod_spec_or_path = external_source[:podspec].present? || external_source[:path].present?
+        if pod_spec_or_path && specified_downloaders.size > 0
+          add_error "The dependency `#{dependency.name}` specifies `podspec` or `path` in combination with other" \
+            ' download strategies. This is not allowed'
+        end
+      end
+
+      # Warns the user if the podfile is empty.
+      #
+      # @note   The workspace is created in any case and all the user projects
+      #         are added to it, however the projects are not integrated as
+      #         there is no way to discern between target definitions which are
+      #         empty and target definitions which just serve the purpose to
+      #         wrap other ones. This is not an issue because empty target
+      #         definitions generate empty libraries.
+      #
+      # @return [void]
+      #
+      def validate_dependencies_are_present!
+        if @podfile_dependency_cache.target_definition_list.all?(&:empty?)
+          add_warning 'The Podfile does not contain any dependencies.'
+        end
+      end
+
+      # Verifies that no dependencies in the Podfile will end up not being built
+      # 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!
+        @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
+
+      def validate_no_duplicate_targets!
+        @podfile_dependency_cache.target_definition_list.group_by { |td| [td.name, td.user_project_path] }.
+          each do |(name, project), definitions|
+          next unless definitions.size > 1
+          error = "The target `#{name}` is declared multiple times"
+          error << " for the project `#{project}`" if project
+          add_error(error << '.')
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/installer/post_install_hooks_context.rb

@@ -0,0 +1,9 @@
+module Pod
+  class Installer
+    # Context object designed to be used with the HooksManager which describes
+    # the context of the installer.
+    #
+    class PostInstallHooksContext < BaseInstallHooksContext
+    end
+  end
+end

data/lib/cocoapods-tt/native/installer/post_integrate_hooks_context.rb

@@ -0,0 +1,9 @@
+module Pod
+  class Installer
+    # Context object designed to be used with the HooksManager which describes
+    # the context of the installer.
+    #
+    class PostIntegrateHooksContext < BaseInstallHooksContext
+    end
+  end
+end

data/lib/cocoapods-tt/native/installer/pre_install_hooks_context.rb

@@ -0,0 +1,51 @@
+module Pod
+  class Installer
+    # Context object designed to be used with the HooksManager which describes
+    # the context of the installer before analysis has been completed.
+    #
+    class PreInstallHooksContext
+      # @return [Podfile] The Podfile for the project.
+      #
+      attr_reader :podfile
+
+      # @return [Sandbox] The Sandbox for the project.
+      #
+      attr_reader :sandbox
+
+      # @return [String] The path to the sandbox root (`Pods` directory).
+      #
+      attr_reader :sandbox_root
+
+      # @return [Lockfile] The Lockfile for the project.
+      #
+      attr_reader :lockfile
+
+      # Initialize a new instance
+      #
+      # @param [Sandbox] sandbox see #sandbox
+      # @param [String] sandbox_root see #sandbox_root
+      # @param [Podfile] podfile see #podfile
+      # @param [Lockfile] lockfile see #lockfile
+      #
+      def initialize(podfile, sandbox, sandbox_root, lockfile)
+        @podfile = podfile
+        @sandbox = sandbox
+        @sandbox_root = sandbox_root
+        @lockfile = lockfile
+      end
+
+      # @param  [Sandbox] sandbox see {#sandbox}
+      #
+      # @param  [Podfile] podfile see {#podfile}
+      #
+      # @param  [Lockfile] lockfile see {#lockfile}
+      #
+      # @return [PreInstallHooksContext] Convenience class method to generate the
+      #         static context.
+      #
+      def self.generate(sandbox, podfile, lockfile)
+        new(podfile, sandbox, sandbox.root.to_s, lockfile)
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/installer/pre_integrate_hooks_context.rb

@@ -0,0 +1,9 @@
+module Pod
+  class Installer
+    # Context object designed to be used with the HooksManager which describes
+    # the context of the installer.
+    #
+    class PreIntegrateHooksContext < BaseInstallHooksContext
+    end
+  end
+end

data/lib/cocoapods-tt/native/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-tt/native/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 [Integer]
+        #         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 [Integer] 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-tt/native/installer/project_cache/project_cache_analyzer.rb

@@ -0,0 +1,200 @@
+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 [Integer] The object version from the user project.
+        #
+        attr_reader :project_object_version
+
+        # @return [Hash<String, Hash>] The podfile plugins to be run for the installation.
+        #
+        attr_reader :podfile_plugins
+
+        # @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 [Hash<Symbol, Object>] Hash of installation options.
+        #
+        attr_reader :installation_options
+
+        # @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 [Integer] project_object_version @see #project_object_version
+        # @param [Hash<String, Hash>] podfile_plugins @see #podfile_plugins
+        # @param [Array<PodTarget>] pod_targets @see #pod_targets
+        # @param [Array<AggregateTarget>] aggregate_targets @see #aggregate_targets
+        # @param [Hash<Symbol, Object>] installation_options @see #installation_options
+        # @param [Bool] clean_install @see #clean_install
+        #
+        def initialize(sandbox, cache, build_configurations, project_object_version, podfile_plugins, pod_targets, aggregate_targets, installation_options,
+                       clean_install: false)
+          @sandbox = sandbox
+          @cache = cache
+          @build_configurations = build_configurations
+          @podfile_plugins = podfile_plugins
+          @pod_targets = pod_targets
+          @aggregate_targets = aggregate_targets
+          @project_object_version = project_object_version
+          @installation_options = installation_options
+          @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 ||
+              YAMLHelper.convert(cache.podfile_plugins) != YAMLHelper.convert(podfile_plugins) ||
+              YAMLHelper.convert(cache.installation_options) != YAMLHelper.convert(installation_options)
+            UI.message 'Ignoring project cache due to project configuration changes.'
+            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 = 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) }
+          pod_targets_to_generate.merge(added_pod_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) }
+          pod_targets_to_generate.merge(changed_pod_targets)
+          aggregate_targets_to_generate.merge(changed_aggregate_targets)
+
+          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.merge(dirty_pod_targets)
+          aggregate_targets_to_generate.merge(dirty_aggregate_targets)
+
+          # 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.
+          total_aggregate_targets_to_generate = unless aggregate_targets_to_generate.empty? && removed_aggregate_target_labels.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)
+        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(sandbox, target, :is_local_pod => local,
+                                                                      :checkout_options => checkout_options)]
+            when AggregateTarget
+              [label, TargetCacheKey.from_aggregate_target(sandbox, target)]
+            else
+              raise "[BUG] Unknown target type #{target}"
+            end
+          end]
+        end
+
+        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
+        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)
+          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.project_name)
+                               when AggregateTarget
+                                 File.exist? sandbox.project_path
+                               else
+                                 raise "[BUG] Unknown target type #{target}"
+                               end
+            support_files_dir_exists && xcodeproj_exists
+          end
+        end
+
+        def compute_sibling_pod_targets(pod_targets, pod_targets_to_generate)
+          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
+  end
+end

data/lib/cocoapods-tt/native/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)
+          Sandbox.update_changed_file(path, version.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/installer/project_cache/project_installation_cache.rb

@@ -0,0 +1,103 @@
+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 [Integer]
+        #         Project object stored in the cache.
+        #
+        attr_reader :project_object_version
+
+        # @return [Hash<String, Hash>]
+        #         Podfile plugins used with a particular install.
+        #
+        attr_reader :podfile_plugins
+
+        # @return [Hash<Symbol, Object>]
+        #         Configured installation options
+        #
+        attr_reader :installation_options
+
+        # 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 [Integer] project_object_version @see #project_object_version
+        # @param [Hash<String, Hash>] podfile_plugins @see #podfile_plugins
+        # @param [Hash<Symbol, Object>] installation_options @see #installation_options
+        #
+        def initialize(cache_key_by_target_label = {}, build_configurations = nil, project_object_version = nil, podfile_plugins = {}, installation_options = {})
+          @cache_key_by_target_label = cache_key_by_target_label
+          @build_configurations = build_configurations
+          @project_object_version = project_object_version
+          @podfile_plugins = podfile_plugins
+          @installation_options = installation_options
+        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 update_podfile_plugins!(podfile_plugins)
+          @podfile_plugins = podfile_plugins
+        end
+
+        def update_installation_options!(installation_options)
+          @installation_options = installation_options
+        end
+
+        def save_as(path)
+          Pathname(path).dirname.mkpath
+          Sandbox.update_changed_file(path, YAMLHelper.convert(to_hash))
+        end
+
+        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(sandbox, key_hash)]
+          end]
+          project_object_version = contents['OBJECT_VERSION']
+          build_configurations = contents['BUILD_CONFIGURATIONS']
+          podfile_plugins = contents['PLUGINS']
+          installation_options = contents['INSTALLATION_OPTIONS']
+          ProjectInstallationCache.new(cache_key_by_target_label, build_configurations, project_object_version, podfile_plugins, installation_options)
+        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['PLUGINS'] = podfile_plugins if podfile_plugins
+          contents['INSTALLATION_OPTIONS'] = installation_options if installation_options
+          contents
+        end
+      end
+    end
+  end
+end