cocoapods-tt 0.0.1

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

@@ -0,0 +1,73 @@
+module Pod
+  class Installer
+    module ProjectCache
+      # Represents the metadata cache
+      #
+      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.
+        #
+        attr_reader :target_label_by_metadata
+
+        # Initialize a new instance.
+        #
+        # @param [Sandbox] sandbox see #sandbox
+        # @param [Hash{String => TargetMetadata}] target_label_by_metadata @see #target_label_by_metadata
+        #
+        def initialize(sandbox, target_label_by_metadata = {})
+          @sandbox = sandbox
+          @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)
+          Sandbox.update_changed_file(path, 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(sandbox, native_target)
+            # app targets need to be added to the cache because they can be used as app hosts for test targets, even if those test targets live inside a different pod (and thus project)
+            installation_result.app_native_targets.each_value do |app_target|
+              target_label_by_metadata[app_target.name] = TargetMetadata.from_native_target(sandbox, app_target)
+            end
+          end
+        end
+
+        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(sandbox, target_by_label_metadata)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,176 @@
+module Pod
+  class Installer
+    module ProjectCache
+      # Uniquely identifies a Target.
+      #
+      class TargetCacheKey
+        require 'cocoapods/target/pod_target.rb'
+        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.
+        #
+        attr_reader :type
+
+        # @return [Hash{String => Object}]
+        #         The hash containing key-value pairs that identify the target.
+        #
+        attr_reader :key_hash
+
+        # 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(sandbox, type, key_hash)
+          @sandbox = sandbox
+          @type = type
+          @key_hash = key_hash
+        end
+
+        # Equality function used to compare TargetCacheKey objects to each other.
+        #
+        # @param [TargetCacheKey] other
+        #        Other object to compare itself against.
+        #
+        # @return [Symbol] The difference between this and another TargetCacheKey object.
+        #         # Symbol :none means no difference.
+        #
+        def key_difference(other)
+          if other.type != type
+            :project
+          else
+            case type
+            when :pod_target
+              return :project if (other.key_hash.keys - key_hash.keys).any?
+              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['PROJECT_NAME'] != key_hash['PROJECT_NAME']
+            end
+
+            this_files = key_hash['FILES']
+            other_files = other.key_hash['FILES']
+            return :project if this_files != other_files
+
+            this_build_settings = key_hash['BUILD_SETTINGS_CHECKSUM']
+            other_build_settings = other.key_hash['BUILD_SETTINGS_CHECKSUM']
+            return :project if this_build_settings != other_build_settings
+
+            this_checkout_options = key_hash['CHECKOUT_OPTIONS']
+            other_checkout_options = other.key_hash['CHECKOUT_OPTIONS']
+            return :project if this_checkout_options != other_checkout_options
+
+            :none
+          end
+        end
+
+        def to_h
+          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(sandbox, key_hash)
+          cache_hash = key_hash.dup
+          if files = cache_hash['FILES']
+            cache_hash['FILES'] = files.sort_by(&:downcase)
+          end
+          if specs = cache_hash['SPECS']
+            cache_hash['SPECS'] = specs.sort_by(&:downcase)
+          end
+          type = cache_hash['CHECKSUM'] ? :pod_target : :aggregate
+          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.
+        #
+        # @param [Bool] is_local_pod
+        #        Used to also include its local files in the cache key.
+        #
+        # @param [Hash] checkout_options
+        #        The checkout options for this pod target.
+        #
+        # @return [TargetCacheKey]
+        #
+        def self.from_pod_target(sandbox, pod_target, is_local_pod: false, checkout_options: nil)
+          build_settings = {}
+          build_settings[pod_target.label.to_s] = Hash[pod_target.build_settings.map do |k, v|
+            [k, Digest::MD5.hexdigest(v.xcconfig.to_s)]
+          end]
+          pod_target.test_spec_build_settings_by_config.each do |name, settings_by_config|
+            build_settings[name] = Hash[settings_by_config.map { |k, v| [k, Digest::MD5.hexdigest(v.xcconfig.to_s)] }]
+          end
+          pod_target.app_spec_build_settings_by_config.each do |name, settings_by_config|
+            build_settings[name] = Hash[settings_by_config.map { |k, v| [k, Digest::MD5.hexdigest(v.xcconfig.to_s)] }]
+          end
+
+          contents = {
+            '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,
+          }
+          if is_local_pod
+            relative_file_paths = pod_target.all_files.map { |f| 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(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(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
+
+          contents = {
+            'BUILD_SETTINGS_CHECKSUM' => build_settings,
+          }
+          if aggregate_target.includes_resources? || aggregate_target.includes_on_demand_resources?
+            relative_resource_file_paths = aggregate_target.resource_paths_by_config.values.flatten.uniq
+            relative_on_demand_resource_file_paths = aggregate_target.on_demand_resources.map do |res|
+              res.relative_path_from(sandbox.project_path.dirname).to_s
+            end
+            contents['FILES'] = (relative_resource_file_paths + relative_on_demand_resource_file_paths).sort_by(&:downcase)
+          end
+          TargetCacheKey.new(sandbox, :aggregate, contents)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Pod
+  class Installer
+    module ProjectCache
+      # Metadata used to reconstruct a PBXTargetDependency.
+      #
+      class TargetMetadata
+        # @return [String]
+        #         The label of the native target.
+        #
+        attr_reader :target_label
+
+        # @return [String]
+        #         The UUID of the native target installed.
+        #
+        attr_reader :native_target_uuid
+
+        # @return [String]
+        #         The path of the container project the native target was installed into.
+        #
+        attr_reader :container_project_path
+
+        # Initialize a new instance.
+        #
+        # @param [String] target_label @see #target_label
+        # @param [String] native_target_uuid @see #native_target_uuid
+        # @param [String] container_project_path @see #container_project_path
+        #
+        def initialize(target_label, native_target_uuid, container_project_path)
+          @target_label = target_label
+          @native_target_uuid = native_target_uuid
+          @container_project_path = container_project_path
+        end
+
+        def to_hash
+          {
+            'LABEL' => target_label,
+            'UUID' => native_target_uuid,
+            'PROJECT_PATH' => container_project_path,
+          }
+        end
+
+        def to_s
+          "#{target_label} : #{native_target_uuid} : #{container_project_path}"
+        end
+
+        # Constructs a TargetMetadata instance from a hash.
+        #
+        # @param [Hash] hash
+        #        The hash used to construct a new TargetMetadata instance.
+        #
+        # @return [TargetMetadata]
+        #
+        def self.from_hash(hash)
+          TargetMetadata.new(hash['LABEL'], hash['UUID'], hash['PROJECT_PATH'])
+        end
+
+        # 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(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
+  end
+end

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

@@ -0,0 +1,105 @@
+module Pod
+  class Installer
+    # Cleans up the sandbox directory by removing stale target support files and headers.
+    #
+    class SandboxDirCleaner
+      # @return [Sandbox] The sandbox directory that will be cleaned.
+      #
+      attr_reader :sandbox
+
+      # @return [Array<PodTarget>]
+      #         The list of all pod targets that will be installed into the Sandbox.
+      #
+      attr_reader :pod_targets
+
+      # @return [Array<AggregateTarget>]
+      #         The list of all aggregate targets that will be installed into the Sandbox.
+      #
+      attr_reader :aggregate_targets
+
+      # Initialize a new instance
+      #
+      # @param [Sandbox] sandbox @see #sandbox
+      # @param [Array<PodTarget>] pod_targets @see #pod_targets
+      # @param [Array<AggregateTarget>] aggregate_targets @see #aggregate_targets
+      #
+      def initialize(sandbox, pod_targets, aggregate_targets)
+        @sandbox = sandbox
+        @pod_targets = pod_targets
+        @aggregate_targets = aggregate_targets
+      end
+
+      def clean!
+        UI.message('Cleaning up sandbox directory') do
+          # Clean up Target Support Files Directory
+          target_support_dirs_to_install = (pod_targets + aggregate_targets).map(&:support_files_dir)
+          target_support_dirs = sandbox_target_support_dirs
+
+          removed_target_support_dirs = target_support_dirs - target_support_dirs_to_install
+          removed_target_support_dirs.each { |dir| remove_dir(dir) }
+
+          # Clean up Sandbox Headers Directory
+          sandbox_private_headers_to_install = pod_targets.flat_map do |pod_target|
+            if pod_target.header_mappings_by_file_accessor.empty?
+              []
+            else
+              [pod_target.build_headers.root.join(pod_target.headers_sandbox)]
+            end
+          end
+          sandbox_public_headers_to_install = pod_targets.flat_map do |pod_target|
+            if pod_target.public_header_mappings_by_file_accessor.empty?
+              []
+            else
+              [
+                sandbox.public_headers.root.join(pod_target.headers_sandbox),
+                pod_target.module_map_path.dirname,
+              ].uniq
+            end
+          end
+
+          removed_sandbox_public_headers = sandbox_public_headers - sandbox_public_headers_to_install
+          removed_sandbox_public_headers.each { |path| remove_dir(path) }
+
+          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]
+          user_project_dir_names = aggregate_targets.map(&:user_project_path).uniq
+
+          removed_project_dir_names = project_dir_names - user_project_dir_names - project_dir_names_to_install
+          removed_project_dir_names.each { |dir| remove_dir(dir) }
+        end
+      end
+
+      private
+
+      def sandbox_target_support_dirs
+        child_directories_of(sandbox.target_support_files_root)
+      end
+
+      def sandbox_private_headers(pod_targets)
+        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
+
+      def child_directories_of(dir)
+        return [] unless dir.exist?
+        dir.children.select(&:directory?)
+      end
+
+      def remove_dir(path)
+        FileUtils.rm_rf(path)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Pod
+  class Installer
+    # Adds all the search paths into the sandbox HeaderStore and each pod target's HeaderStore.
+    #
+    class SandboxHeaderPathsInstaller
+      # @return [Sandbox] The sandbox to use for this analysis.
+      #
+      attr_reader :sandbox
+
+      # @return [Array<PodTarget>] The list of pod targets to analyze.
+      #
+      attr_reader :pod_targets
+
+      # Initialize a new instance
+      #
+      # @param  [Sandbox] sandbox @see #sandbox
+      # @param  [Array<PodTarget>] pod_targets @see #pod_targets
+      #
+      def initialize(sandbox, pod_targets)
+        @pod_targets = pod_targets
+        @sandbox = sandbox
+      end
+
+      def install!
+        # Link all pod target header search paths into the HeaderStore.
+        pod_targets.each do |pod_target|
+          next if pod_target.build_as_framework? && pod_target.should_build?
+          install_target(pod_target)
+        end
+      end
+
+      private
+
+      def install_target(pod_target)
+        pod_target_header_mappings = pod_target.header_mappings_by_file_accessor.values
+        public_header_mappings = pod_target.public_header_mappings_by_file_accessor.values
+        added_build_headers = !pod_target_header_mappings.all?(&:empty?)
+        added_public_headers = !public_header_mappings.all?(&:empty?)
+
+        pod_target.build_headers.add_search_path(pod_target.headers_sandbox, pod_target.platform) if added_build_headers
+        sandbox.public_headers.add_search_path(pod_target.headers_sandbox, pod_target.platform) if added_public_headers
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Pod
+  class Installer
+    # Context object designed to be used with the HooksManager which describes
+    # the context of the installer before spec sources have been created
+    #
+    class SourceProviderHooksContext
+      # @return [Array<Source>] The source objects to send to the installer
+      #
+      attr_reader :sources
+
+      # @return [SourceProviderHooksContext] Convenience class method to generate the
+      #         static context.
+      #
+      def self.generate
+        result = new
+        result
+      end
+
+      def initialize
+        @sources = []
+      end
+
+      # @param [Source] source object to be added to the installer
+      #
+      # @return [void]
+      #
+      def add_source(source)
+        unless source.nil?
+          @sources << source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Pod
+  class Installer
+    # Generates stable UUIDs for Native Targets.
+    #
+    class TargetUUIDGenerator < Xcodeproj::Project::UUIDGenerator
+      # This method override is used to ONLY generate stable UUIDs for PBXNativeTarget instances and their sibling PBXFileReference
+      # product reference in the project. Stable native target UUIDs are necessary for incremental installation
+      # because other projects reference the target and product reference by its UUID in the remoteGlobalIDString field.
+      #
+      # @param [Array<Project>] projects
+      #        The list of projects used to generate stabe target UUIDs.
+      #
+      def generate_all_paths_by_objects(projects)
+        @paths_by_object = {}
+        projects.each do |project|
+          project_basename = project.path.basename.to_s
+          project.objects.each do |object|
+            @paths_by_object[object] = object.uuid
+          end
+          project.targets.each do |target|
+            @paths_by_object[target] = Digest::MD5.hexdigest(project_basename + target.name).upcase
+            if target.is_a? Xcodeproj::Project::Object::PBXNativeTarget
+              @paths_by_object[target.product_reference] = Digest::MD5.hexdigest(project_basename + 'product_reference' + target.name).upcase
+            end
+          end
+        end
+      end
+
+      def uuid_for_path(path)
+        path
+      end
+    end
+  end
+end